All-in-One-Colab-Notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dropcreations/Essential-Google-Colab-Notebook/blob/main/All-in-One-Colab-Notebook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __Mount Google Drive__"
      ],
      "metadata": {
        "id": "qC6PmtJYyK2A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/Google-Drive-Logo.svg' height=\"50\" alt=\"google-drive-logo\"/></center>\n",
        "#@markdown <center><h3><b>Mount Google Drive</b></h3></center><br>\n",
        "\n",
        "from google.colab import drive\n",
        "\n",
        "mode = \"Mount\" #@param [\"Mount\", \"Unmount\"]\n",
        "drive.mount._DEBUG = False\n",
        "\n",
        "if mode == \"Mount\":\n",
        "    drive.mount('/content/drive', force_remount=True)\n",
        "elif mode == \"Unmount\":\n",
        "    try: drive.flush_and_unmount()\n",
        "    except ValueError: pass\n",
        "    !rm -rf /root/.config/Google/DriveFS"
      ],
      "metadata": {
        "cellView": "form",
        "id": "0Il1pfgPyP7c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __Manage Files & Folders__"
      ],
      "metadata": {
        "id": "kv8re6A5M9eN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Copy Files & Folders__"
      ],
      "metadata": {
        "id": "1t2tjkHSwQTa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `sourcePath`: add source file's or folder's path.\n",
        "* You can add more source paths and seperate each by **a comma and a space**.\n",
        "> **eg**: `sourcePath: [file01], [file02], [folder01], [folder02], [file03], [file04]`\n",
        "* `onlyContent`: use this when coping the **content of a folder**.\n",
        "> * when adding *`/content/testFolder`* will copy the content in *`testFolder`* folder, not the entire *`testFolder`*.\n",
        "> * If you have added more folder paths, this will copy **only the content** in all those folders.\n",
        "* `Update`: copy only when the **source file is newer than the destination file** or when **the destination file is missing**."
      ],
      "metadata": {
        "id": "InVX1EfkwpsY"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3gfHaLWfv_st",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "\n",
        "sourcePath = \"\" #@param {type: 'string'}\n",
        "targetPath = \"\" #@param {type: 'string'}\n",
        "onlyContent = False #@param {type:\"boolean\"}\n",
        "update = False #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = '--verbose --strip-trailing-slashes --recursive --interactive '\n",
        "if update: commandLine = '--verbose --recursive --update '\n",
        "\n",
        "sourceList = []\n",
        "\n",
        "for inputFile in sourcePath.split(', '):\n",
        "    if os.path.isfile(inputFile):\n",
        "        sourceList.append(f'\"{inputFile}\"')\n",
        "    else:\n",
        "        if onlyContent: inputFile = f'\"{inputFile}/*\"'\n",
        "        else: inputFile = f'\"{inputFile}\"'\n",
        "        sourceList.append(inputFile)\n",
        "\n",
        "sourceParam = ' '.join(sourceList)\n",
        "commandLine += f'{sourceParam} --target-directory \"{targetPath}\"'\n",
        "\n",
        "!cp {commandLine}"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Move Files & Folders__"
      ],
      "metadata": {
        "id": "zeofhBho1VJ5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `sourcePath`: add source file's or folder's path.\n",
        "* You can add more source paths and seperate each by **a comma and a space**.\n",
        "> **eg**: `sourcePath: [file01], [file02], [folder01], [folder02], [file03], [file04]`\n",
        "* `onlyContent`: use this when moving the **content of a folder**.\n",
        "> * when adding *`/content/testFolder`* will move the content in *`testFolder`* folder, not the entire *`testFolder`*.\n",
        "> * If you have added more folder paths, this will copy **only the content** in all those folders.\n",
        "* `Update`: move only when the **source file is newer than the destination file** or when **the destination file is missing**."
      ],
      "metadata": {
        "id": "-etmUnuN11dB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "sourcePath = \"\" #@param {type: 'string'}\n",
        "targetPath = \"\" #@param {type: 'string'}\n",
        "onlyContent = False #@param {type:\"boolean\"}\n",
        "update = False #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = '--verbose --strip-trailing-slashes --interactive '\n",
        "if update: commandLine = '--verbose --update '\n",
        "\n",
        "sourceList = []\n",
        "\n",
        "for inputFile in sourcePath.split(', '):\n",
        "    if os.path.isfile(inputFile):\n",
        "        sourceList.append(f'\"{inputFile}\"')\n",
        "    else:\n",
        "        if onlyContent: inputFile = f'\"{inputFile}/*\"'\n",
        "        else: inputFile = f'\"{inputFile}\"'\n",
        "        sourceList.append(inputFile)\n",
        "\n",
        "sourceParam = ' '.join(sourceList)\n",
        "commandLine += f'{sourceParam} --target-directory \"{targetPath}\"'\n",
        "\n",
        "!mv {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Eg_ijA3r12nA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Delete Files & Folders__"
      ],
      "metadata": {
        "id": "p-VDriIv1Xr1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `sourcePath`: add source file's or folder's path.\n",
        "* You can add more source paths and seperate each by **a comma and a space**.\n",
        "> **eg**: `sourcePath: [file01], [file02], [folder01], [folder02], [file03], [file04]`\n",
        "* `onlyContent`: use this when deleting the **content of a folder**.\n",
        "> * when adding *`/content/testFolder`* will delete the content in *`testFolder`* folder, not the entire *`testFolder`*.\n",
        "> * If you have added more folder paths, this will remove **only the content** in all those folders."
      ],
      "metadata": {
        "id": "BFg4mjx818V3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "sourcePath = \"\" #@param {type: 'string'}\n",
        "onlyContent = False #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = \"--verbose --no-preserve-root --dir --recursive \"\n",
        "sourceList = []\n",
        "\n",
        "for inputFile in sourcePath.split(', '):\n",
        "    if os.path.isfile(inputFile):\n",
        "        sourceList.append(f'\"{inputFile}\"')\n",
        "    else:\n",
        "        if onlyContent: inputFile = f'\"{inputFile}/*\"'\n",
        "        else: inputFile = f'\"{inputFile}\"'\n",
        "        sourceList.append(inputFile)\n",
        "\n",
        "sourceParam = ' '.join(sourceList)\n",
        "commandLine += sourceParam\n",
        "\n",
        "!rm {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "PiZU4Jvx19Qw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __View Folder Size__"
      ],
      "metadata": {
        "id": "FgSWQm1RMpvD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* This will show the size of **folders and sub folders only**. to view all files **select** `viewContent`.\n",
        "* `modificationTime` : Use this to **view time information** of files.\n",
        "* If `Summary` is selected, only shows the **total size** of the folder, So ***uncheck*** it to use `viewContent` option."
      ],
      "metadata": {
        "id": "buQEVatAMlk0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sourcePath = \"\" #@param {type:\"string\"}\n",
        "modificationTimeStyle = \"long-iso\" #@param [\"full-iso\", \"long-iso\", \"iso\"]\n",
        "modificationTimeType = \"atime\" #@param [\"atime\", \"access\", \"use\", \"ctime\", \"status\"]\n",
        "modificationTime = False #@param {type:\"boolean\"}\n",
        "viewContent = False #@param {type:\"boolean\"}\n",
        "summary = True #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = \"--human-readable \"\n",
        "\n",
        "if summary: commandLine += \"--summarize \"\n",
        "else:\n",
        "    if viewContent: commandLine += \"-a \"\n",
        "\n",
        "if modificationTime:\n",
        "    commandLine += f'--time={modificationTimeType} --time-style={modificationTimeStyle} '\n",
        "\n",
        "commandLine += f'\"{sourcePath}\"'\n",
        "\n",
        "!du {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "J_nZFmN0Mg3N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __7-Zip__"
      ],
      "metadata": {
        "id": "tNjKvW1mcFzq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **Install 7-Zip** to the runtime"
      ],
      "metadata": {
        "id": "OgxDHlDAzNbz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/main/cell_logos/7-zip-Logo.png' height=\"50\" alt=\"7zip-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install 7-Zip</b></h3></center><br>\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!sudo curl -L https://www.7-zip.org/a/7z2301-linux-x64.tar.xz -o /usr/local/bin/7zip.tar.xz\n",
        "%cd /usr/local/bin/\n",
        "!7z e -y /usr/local/bin/7zip.tar.xz\n",
        "!7z x -y /usr/local/bin/7zip.tar 7zz\n",
        "!rm /usr/local/bin/7zip.tar.xz\n",
        "!rm /usr/local/bin/7zip.tar\n",
        "!sudo chmod +x /usr/local/bin/7zz\n",
        "clear_output()\n",
        "!7zz | sed -n 2p"
      ],
      "metadata": {
        "id": "I1gBaSB8zAn8",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Compress Files and Folders__"
      ],
      "metadata": {
        "id": "rptJuNkMy7Sk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Create **zip, tar, 7z, gz, bz2, xz, wim** files.\n",
        "* If you want you can add **password** or **split** the archive.\n",
        "* If you want to save archive in **another** location **uncheck** `saveToSourceLocation`."
      ],
      "metadata": {
        "id": "gjMt7mdw0bon"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "sourcePath = \"\" #@param {type:\"string\"}\n",
        "compressType = \"zip\" #@param [\"zip\", \"7z\", \"tar\", \"gzip\", \"bzip2\", \"xz\", \"wim\"]\n",
        "Password = \"\" #@param {type:\"string\"}\n",
        "Split = \"no\" #@param [\"no\", \"10m\", \"100m\", \"500m\", \"1g\", \"2g\"] {allow-input: true}\n",
        "compressLevel = 9 #@param {type:\"slider\", min:0, max:9, step:1}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = \"-t\" + compressType + \" -mx=\" + str(compressLevel)\n",
        "\n",
        "if len(Password) > 0:\n",
        "    commandLine = commandLine + \" -p\" + '\"' + Password + '\"'\n",
        "\n",
        "if Split != \"no\":\n",
        "    commandLine = commandLine + \" -v\" + '\"' + Split + '\"'\n",
        "\n",
        "if os.path.isfile(sourcePath):\n",
        "    sourceName = os.path.splitext(os.path.basename(os.path.abspath(sourcePath)))[0]\n",
        "    sourceFolder = os.path.dirname(os.path.abspath(sourcePath))\n",
        "else:\n",
        "    sourceName = os.path.split(os.path.abspath(sourcePath))[1]\n",
        "    sourceFolder = os.path.split(os.path.abspath(sourcePath))[0]\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    compressPath = os.path.join(sourceFolder, \"compressed\")\n",
        "    commandLine = commandLine + ' \"' + compressPath + '\"'\n",
        "else:\n",
        "    outputPath = input(\"outputPath: \")\n",
        "    if outputPath.endswith('.zip') or outputPath.endswith('.7z') or outputPath.endswith('.tar') or outputPath.endswith('.gz') or outputPath.endswith('.bz2') or outputPath.endswith('.xz') or outputPath.endswith('.wim'):\n",
        "        sourceName = os.path.splitext(os.path.basename(os.path.abspath(outputPath)))[0]\n",
        "        sourceFolder = os.path.dirname(os.path.abspath(outputPath))\n",
        "    else:\n",
        "        if not os.path.exists(outputPath):\n",
        "            os.makedirs(outputPath)\n",
        "        sourceFolder = outputPath\n",
        "    compressPath = os.path.join(sourceFolder, \"compressed\")\n",
        "    commandLine = commandLine + ' \"' + compressPath + '\"'\n",
        "\n",
        "if compressType == \"gzip\":\n",
        "    formatFile = \"gz\"\n",
        "elif compressType == \"bzip2\":\n",
        "    formatFile = \"bz2\"\n",
        "else:\n",
        "    formatFile = compressType\n",
        "\n",
        "!7zz a {commandLine} \"{sourcePath}\"\n",
        "saveFile = os.path.join(sourceFolder, sourceName)\n",
        "compressPath = compressPath + '.' + formatFile\n",
        "saveFile = saveFile + '.' + formatFile\n",
        "os.rename(compressPath, saveFile)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "WLH3brY_zoWp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Uncompress Files__"
      ],
      "metadata": {
        "id": "S3sGwFQa1XWv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* To **list content** of the file, use `viewFile`. ***Uncheck this after viewing the content***.\n",
        "* Can also extract **splited** archives.\n",
        "* `saveToSourceLocation`: Extracts files to source location.\n",
        "* If you want to extract files from archive **without using directory names**, uncheck `directoryNames`.\n",
        "> * NOTE : ***Don't uncheck*** `directoryNames` at normal use.\n",
        ">\n",
        ">  ![directory_names](https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/main/cell_logos/directory_names.png) ![without_directory_names](https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/main/cell_logos/without_directory_names.png)\n",
        ">\n",
        "> * Without `directoryNames`, extracts files as **2nd figure**."
      ],
      "metadata": {
        "id": "IaseMFuV2Egd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "sourceFile = \"\" #@param {type:\"string\"}\n",
        "viewFile = False #@param {type:\"boolean\"}\n",
        "directoryNames = True #@param {type:\"boolean\"}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(sourceFile)))[0]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(sourceFile))\n",
        "\n",
        "if viewFile: commandLine = 'l \"' + sourceFile + '\"'\n",
        "else:\n",
        "    makeFolder = input(\"Do you want to create a folder to extract? [y/n] \")\n",
        "    if saveToSourceLocation:\n",
        "        if makeFolder.lower() == \"y\":\n",
        "            extractFolder = os.path.join(sourceFolder, sourceName)\n",
        "            if not os.path.exists(extractFolder):\n",
        "                os.makedirs(extractFolder, exist_ok=True)\n",
        "        elif makeFolder.lower() == \"n\":\n",
        "            extractFolder = sourceFolder\n",
        "    else:\n",
        "        outputPath = input(\"outputFolder: \")\n",
        "        if makeFolder.lower() == \"y\":\n",
        "            extractFolder = os.path.join(outputPath, sourceName)\n",
        "            if not os.path.exists(extractFolder):\n",
        "                os.makedirs(extractFolder, exist_ok=True)\n",
        "        elif makeFolder.lower() == \"n\":\n",
        "            extractFolder = outputPath\n",
        "    if directoryNames: commandLine = 'x \"' + sourceFile + '\" -o\"' + extractFolder + '\"'\n",
        "    else: commandLine = 'e \"' + sourceFile + '\" -o\"' + extractFolder + '\"'\n",
        "\n",
        "!7zz {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "ySl6pjEw2CY9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __Transfer files to Google Drive__"
      ],
      "metadata": {
        "id": "cC3puMn6310A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Transfer files between two Google drives__"
      ],
      "metadata": {
        "id": "ck_J6PLW7euo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to mount **first Google Drive** to **\"content/drive-01\"**"
      ],
      "metadata": {
        "id": "h8RFjWog7tMp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/Google-Drive-Logo.svg' height=\"50\" alt=\"Gdrive-logo\"/></center>\n",
        "#@markdown <center><h3><b>Mount 1<sup>st</sup> Google Drive</b></h3></center><br>\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive-01')"
      ],
      "metadata": {
        "id": "63E8rHhL76Lf",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to mount **Second Google Drive** to **\"content/drive-02\"**"
      ],
      "metadata": {
        "id": "J9p-ApwY8CPQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/Google-Drive-Logo.svg' height=\"50\" alt=\"Gdrive-logo\"/></center>\n",
        "#@markdown <center><h3><b>Mount 2<sup>nd</sup> Google Drive</b></h3></center><br>\n",
        "!apt-get install -y -qq software-properties-common module-init-tools\n",
        "!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null\n",
        "!apt-get update -qq 2>&1 > /dev/null\n",
        "!apt-get -y install -qq google-drive-ocamlfuse fuse\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "from oauth2client.client import GoogleCredentials\n",
        "creds = GoogleCredentials.get_application_default()\n",
        "import getpass\n",
        "!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL\n",
        "vcode = getpass.getpass()\n",
        "!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}\n",
        "!mkdir -p /content/drive-02\n",
        "!google-drive-ocamlfuse /content/drive-02"
      ],
      "metadata": {
        "id": "DWDUmia38ItY",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `sourcePath`: add source file's or folder's path.\n",
        "* You can add more source paths and seperate each by **a comma and a space**.\n",
        "> **eg**: `sourcePath: [file01], [file02], [folder01], [folder02], [file03], [file04]`\n",
        "* `onlyContent`: use this when coping the **content of a folder**.\n",
        "> * when adding *`/content/testFolder`* will copy the content in *`testFolder`* folder, not the entire *`testFolder`*.\n",
        "> * If you have added more folder paths, this will copy **only the content** in all those folders.\n",
        "* `Update`: copy only when the **source file is newer than the destination file** or when **the destination file is missing**."
      ],
      "metadata": {
        "id": "pSaSjWyrMFPB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "sourcePath = \"\" #@param {type: 'string'}\n",
        "targetPath = \"\" #@param {type: 'string'}\n",
        "onlyContent = False #@param {type:\"boolean\"}\n",
        "update = False #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = '--verbose --strip-trailing-slashes --recursive --interactive '\n",
        "if update: commandLine = '--verbose --recursive --update '\n",
        "\n",
        "sourceList = []\n",
        "\n",
        "for inputFile in sourcePath.split(', '):\n",
        "    if os.path.isfile(inputFile):\n",
        "        sourceList.append(f'\"{inputFile}\"')\n",
        "    else:\n",
        "        if onlyContent: inputFile = f'\"{inputFile}/*\"'\n",
        "        else: inputFile = f'\"{inputFile}\"'\n",
        "        sourceList.append(inputFile)\n",
        "\n",
        "sourceParam = ' '.join(sourceList)\n",
        "commandLine += sourceParam + ' --target-directory \"' + targetPath + '\"'\n",
        "\n",
        "!cp {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Z6LdJB5ZL-xu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Transfer files from direct links__"
      ],
      "metadata": {
        "id": "aau0-HFi4ymP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### __wget__"
      ],
      "metadata": {
        "id": "k7QIRlChypwY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Transfer files from **direct links** to google drive.\n",
        "* Enter the folder path where you want to save the file.\n",
        "* Run below cell to add direct link."
      ],
      "metadata": {
        "id": "5qMP36Ra4GiJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "savePath = '' #@param {type: 'string'}\n",
        "url = '' #@param {type: 'string'}\n",
        "\n",
        "!wget -P \"{savePath}\" \"{url}\""
      ],
      "metadata": {
        "cellView": "form",
        "id": "aPTrv96e4aHv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### __JDownloader__"
      ],
      "metadata": {
        "id": "7O3DwJ4WysdA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to install **JDownloader** to get **WEB-UI**."
      ],
      "metadata": {
        "id": "KvofTI7zI1DB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/jDownloader-Logo.svg' height=\"60\" alt=\"JDownloader-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install JDownloader</b></h3></center><br>\n",
        "\n",
        "import os, uuid, re, IPython\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "Email = widgets.Text(placeholder=\"*Required\", description=\"Email:\")\n",
        "Password = widgets.Text(placeholder=\"*Required\", description=\"Password:\")\n",
        "Device = widgets.Text(placeholder=\"Optional\", description=\"Name:\")\n",
        "SavePath = widgets.Dropdown(value=\"/content\", options=[\"/content\", \"/content/Downloads\"], description=\"Save Path:\")\n",
        "\n",
        "class MakeButton(object):\n",
        "    def __init__(self, title, callback, style):\n",
        "        self._title = title\n",
        "        self._callback = callback\n",
        "        self._style = style\n",
        "\n",
        "    def _repr_html_(self):\n",
        "        callback_id = 'button-' + str(uuid.uuid4())\n",
        "        output.register_callback(callback_id, self._callback)\n",
        "\n",
        "        if self._style != \"\":\n",
        "            style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "        else:\n",
        "            style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "\n",
        "        template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "            <script>\n",
        "            document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "                google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "                e.preventDefault();\n",
        "            }};\n",
        "            </script>\"\"\"\n",
        "        html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "        return html\n",
        "\n",
        "def MakeLabel(description, button_style):\n",
        "    return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RefreshPath():\n",
        "    if os.path.exists(\"/content/drive/\"):\n",
        "        if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "            SavePath.options = [\n",
        "               \"/content\",\n",
        "               \"/content/Downloads\",\n",
        "               \"/content/drive/My Drive\"\n",
        "            ] + glob(\"/content/drive/Shared drives/*\")\n",
        "        else:\n",
        "            SavePath.options = [\n",
        "               \"/content\",\n",
        "               \"/content/Downloads\",\n",
        "               \"/content/drive/My Drive\"\n",
        "            ]\n",
        "    else:\n",
        "        SavePath.options = [\n",
        "           \"/content\",\n",
        "           \"/content/Downloads\"\n",
        "        ]\n",
        "\n",
        "def LoginForm():\n",
        "    clear_output()\n",
        "\n",
        "    Email.value = \"\"\n",
        "    Password.value = \"\"\n",
        "    Device.value = \"\"\n",
        "\n",
        "    RefreshPath()\n",
        "\n",
        "    display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">If you don't have an account yet, please register <a href=\\\"https://my.jdownloader.org/login.html#register\\\" target=\\\"_blank\\\">here</a>.</h3>\"), HTML(\"<br>\"), Email, Password, Device, SavePath)\n",
        "\n",
        "    if not os.path.exists(\"/content/drive/\"):\n",
        "        display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "\n",
        "    display(HTML(\"<br>\"), MakeButton(\"Login\", CheckLogin, \"info\"))\n",
        "\n",
        "    if os.path.isfile(\"/root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\"):\n",
        "        display(MakeButton(\"Cancel\", Show, \"danger\"))\n",
        "\n",
        "def RestartForm():\n",
        "    clear_output()\n",
        "    display(MakeLabel(\"Restart Confirm?\", \"\"), MakeButton(\"Confirm\", Restart, \"danger\"), MakeButton(\"Cancel\", Show, \"warning\"))\n",
        "\n",
        "def ExitForm():\n",
        "    clear_output()\n",
        "    display(MakeLabel(\"Exit Confirm?\", \"\"), MakeButton(\"Confirm\", Exit, \"danger\"), MakeButton(\"Cancel\", Show, \"warning\"))\n",
        "\n",
        "def CheckLogin():\n",
        "    try:\n",
        "        if not Email.value.strip():\n",
        "            ERROR = \"Email field is empty.\"\n",
        "            THROW_ERROR\n",
        "        if not \"@\" in Email.value and not \".\" in Email.value:\n",
        "            ERROR = \"Email is an incorrect format.\"\n",
        "            THROW_ERROR\n",
        "        if not Password.value.strip():\n",
        "            ERROR = \"Password field is empty.\"\n",
        "            THROW_ERROR\n",
        "        if not bool(re.match(\"^[a-zA-Z0-9]+$\", Device.value)) and Device.value.strip():\n",
        "            ERROR = \"Only alphanumeric are allowed for the device name.\"\n",
        "            THROW_ERROR\n",
        "        Login()\n",
        "    except:\n",
        "        print(ERROR)\n",
        "\n",
        "def Login():\n",
        "    clear_output()\n",
        "    if SavePath.value == \"/content\":\n",
        "        get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"/content\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "    elif SavePath.value == \"/content/Downloads\":\n",
        "        get_ipython().system_raw(\"mkdir -p -m 666 /content/Downloads\")\n",
        "        get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"/content/Downloads\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "    else:\n",
        "        get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"\" + SavePath.value + \"\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "    if Device.value.strip() == \"\":\n",
        "        Device.value = Email.value\n",
        "    get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "    get_ipython().system_raw(\"echo '{\\\"email\\\" : \\\"'\" + Email.value + \"'\\\", \\\"password\\\" : \\\"'\" + Password.value + \"'\\\", \\\"devicename\\\" : \\\"'\" + Device.value + \"'\\\", \\\"directconnectmode\\\" : \\\"LAN\\\"}' > /root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\")\n",
        "    get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "    Show()\n",
        "\n",
        "def Restart():\n",
        "    get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "    get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "    Show()\n",
        "\n",
        "def Exit():\n",
        "    get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "    clear_output()\n",
        "    display(MakeButton(\"Start\", Restart, \"info\"))\n",
        "\n",
        "def Show():\n",
        "    clear_output()\n",
        "    display(MakeLabel(\"Control Panel\", \"\"), HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">You can login to the WebUI by clicking <a href=\\\"https://my.jdownloader.org/\\\" target=\\\"_blank\\\">here</a>.</h3>\"), HTML(\"<h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">If the server didn't showup in 30 sec. please re-login.</h4>\"), HTML(\"<br>\"), MakeButton(\"Re-Login\", LoginForm, \"info\"), MakeButton(\"Restart\", RestartForm, \"warning\"), MakeButton(\"Exit\", ExitForm, \"danger\"))\n",
        "\n",
        "\n",
        "if not os.path.isfile(\"/root/.JDownloader/JDownloader.jar\"):\n",
        "    clear_output()\n",
        "    display(MakeLabel(\"Installing in Progress\", \"warning\"))\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data/ && apt install openjdk-8-jre-headless -qq -y && mkdir -p -m 666 /root/.JDownloader && wget -q http://installer.jdownloader.org/JDownloader.jar -O /root/.JDownloader/JDownloader.jar && java -jar /root/.JDownloader/JDownloader.jar -norestart -h\")\n",
        "    LoginForm()\n",
        "elif not os.path.isfile(\"/root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\"):\n",
        "    LoginForm()\n",
        "else: Show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "JkUiWpuIIyUZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Transfer files from MEGA__"
      ],
      "metadata": {
        "id": "4awEZXoM5Iw2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **start** transfer.\n",
        "* If you have a **Mega Pro** account, select `megaProAccount` to **sign in** to use its bandwidth (transfer quota)\n",
        "* You can also add a **public link** without a Pro account, but it has **transfer limits**.\n",
        "* If `savePath` is not provided, files will be transfered to `/content/MEGAdownloads`.\n",
        "* Sometimes this cell doesn't stop itself after the completion of the transfer. In case of that **stop the cell manually**."
      ],
      "metadata": {
        "id": "1uFuEyBX5pTV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://github.com/dropcreations/Essential-Google-Colab-Notebook/blob/main/cell_logos/Mega-Logo.png?raw=true' height=\"60\" alt=\"MEGA-logo\"/></center>\n",
        "#@markdown <center><h2><b>Transfer from Mega</b></h2></center><br>\n",
        "\n",
        "import os\n",
        "import sys\n",
        "import time\n",
        "import shlex\n",
        "import errno\n",
        "import signal\n",
        "import subprocess\n",
        "import contextlib\n",
        "import urllib.request\n",
        "from IPython.display import clear_output\n",
        "from functools import wraps\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ocr.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/OneClickRun/master/res/ocr.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ocr.py\")\n",
        "\n",
        "from ocr import runSh, loadingAn\n",
        "\n",
        "url = \"\" #@param {type:\"string\"}\n",
        "savePath = \"\" #@param {type:\"string\"}\n",
        "megaProAccount = False #@param {type:\"boolean\"}\n",
        "\n",
        "if megaProAccount == True:\n",
        "    class TimeoutError(Exception):\n",
        "        pass\n",
        "\n",
        "    def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\n",
        "        def decorator(func):\n",
        "            def _handle_timeout(signum, frame):\n",
        "                raise TimeoutError(error_message)\n",
        "            def wrapper(*args, **kwargs):\n",
        "                signal.signal(signal.SIGALRM, _handle_timeout)\n",
        "                signal.alarm(seconds)\n",
        "                try:\n",
        "                    result = func(*args, **kwargs)\n",
        "                finally:\n",
        "                    signal.alarm(0)\n",
        "                return result\n",
        "            return wraps(func)(wrapper)\n",
        "        return decorator\n",
        "\n",
        "\n",
        "    if not os.path.exists(\"/root/.ipython/ocr.py\"):\n",
        "        from subprocess import run\n",
        "        from shlex import split\n",
        "        shellCmd = \"wget -qq https://raw.githubusercontent.com/biplobsd/OneClickRun/master/res/ocr.py -O /root/.ipython/ocr.py\"\n",
        "        run(split(shellCmd))\n",
        "\n",
        "    @timeout(10)\n",
        "    def runShT(args):\n",
        "        return runSh(args, output=True)\n",
        "\n",
        "    # MEGAcmd installing\n",
        "    if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "        print(\"Installing MEGA ...\")\n",
        "        runSh('sudo apt-get -y update')\n",
        "        runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "        runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "        runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "        print(\"MEGA is installed.\")\n",
        "    else:\n",
        "        !pkill mega-cmd\n",
        "\n",
        "    # INPUT YOUR MEGA ID\n",
        "    USERNAME = input(\"Username: \")\n",
        "    PASSWORD = input(\"Password: \")\n",
        "    if not (USERNAME == \"\" or PASSWORD == \"\"):\n",
        "        try:\n",
        "            runShT(f\"mega-login {USERNAME} {PASSWORD}\")\n",
        "        except TimeoutError:\n",
        "            runSh('mega-whoami', output=True)\n",
        "        if not savePath:\n",
        "            os.makedirs(\"/content/MEGAdownloads\", exist_ok=True)\n",
        "            savePath = \"/content/MEGAdownloads\"\n",
        "        # MEGAcmd installing\n",
        "        if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "            loadingAn()\n",
        "            print(\"Installing MEGA ...\")\n",
        "            runSh('sudo apt-get -y update')\n",
        "            runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "            runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "            runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "            print(\"MEGA is installed.\")\n",
        "            clear_output()\n",
        "\n",
        "        # Unix, Windows and old Macintosh end-of-line\n",
        "        newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "        def unbuffered(proc, stream='stdout'):\n",
        "            stream = getattr(proc, stream)\n",
        "            with contextlib.closing(stream):\n",
        "                while True:\n",
        "                    out = []\n",
        "                    last = stream.read(1)\n",
        "                    # Don't loop forever\n",
        "                    if last == '' and proc.poll() is not None:\n",
        "                        break\n",
        "                    while last not in newlines:\n",
        "                        # Don't loop forever\n",
        "                        if last == '' and proc.poll() is not None:\n",
        "                            break\n",
        "                        out.append(last)\n",
        "                        last = stream.read(1)\n",
        "                    out = ''.join(out)\n",
        "                    yield out\n",
        "\n",
        "        def transfare():\n",
        "            import codecs\n",
        "            decoder = codecs.getincrementaldecoder(\"UTF-8\")()\n",
        "            cmd = [\"mega-get\", url, savePath]\n",
        "            proc = subprocess.Popen(\n",
        "                cmd,\n",
        "                stdout=subprocess.PIPE,\n",
        "                stderr=subprocess.STDOUT,\n",
        "                # Make all end-of-lines '\\n'\n",
        "                universal_newlines=True,\n",
        "            )\n",
        "            for line in unbuffered(proc):\n",
        "                clear_output()\n",
        "                print(line)\n",
        "        transfare()\n",
        "    else:\n",
        "        clear_output()\n",
        "        print(\"Please Input your Mega IDs.\")\n",
        "else:\n",
        "    if not savePath:\n",
        "        os.makedirs(\"/content/MEGAdownloads\", exist_ok=True)\n",
        "        savePath = \"/content/MEGAdownloads\"\n",
        "    # MEGAcmd installing\n",
        "    if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "        loadingAn()\n",
        "        print(\"Installing MEGA ...\")\n",
        "        runSh('sudo apt-get -y update')\n",
        "        runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "        runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "        runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "        print(\"MEGA is installed.\")\n",
        "        clear_output()\n",
        "\n",
        "    # Unix, Windows and old Macintosh end-of-line\n",
        "    newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "    def unbuffered(proc, stream='stdout'):\n",
        "        stream = getattr(proc, stream)\n",
        "        with contextlib.closing(stream):\n",
        "            while True:\n",
        "                out = []\n",
        "                last = stream.read(1)\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                while last not in newlines:\n",
        "                    # Don't loop forever\n",
        "                    if last == '' and proc.poll() is not None:\n",
        "                        break\n",
        "                    out.append(last)\n",
        "                    last = stream.read(1)\n",
        "                out = ''.join(out)\n",
        "                yield out\n",
        "\n",
        "    def transfare():\n",
        "        import codecs\n",
        "        decoder = codecs.getincrementaldecoder(\"UTF-8\")()\n",
        "        cmd = [\"mega-get\", url, savePath]\n",
        "        proc = subprocess.Popen(\n",
        "            cmd,\n",
        "            stdout=subprocess.PIPE,\n",
        "            stderr=subprocess.STDOUT,\n",
        "            # Make all end-of-lines '\\n'\n",
        "            universal_newlines=True,\n",
        "        )\n",
        "        for line in unbuffered(proc):\n",
        "            clear_output()\n",
        "            print(line)\n",
        "    transfare()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "XD1aChxV6JFk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Transfer files from Torrents__"
      ],
      "metadata": {
        "id": "AcTohvek9bkK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### __libtorrent__"
      ],
      "metadata": {
        "id": "riFKxeH5yW_p"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **install libtorrent** to the runtime."
      ],
      "metadata": {
        "id": "-akAewDC9g3Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://www.libtorrent.org/img/logo-color.png' height=\"50\" alt=\"libtorrent-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install libtorrent</b></h3></center><br>\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!python -m pip install lbry-libtorrent\n",
        "!apt install python3-libtorrent\n",
        "\n",
        "clear_output()\n",
        "print(\"Successfully Installed.\")"
      ],
      "metadata": {
        "id": "iM8aKzEq9rQD",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `savePath`: add folder path where you want to download.\n",
        "* `torrentFile`: use a torrent file to download.\n",
        "* `magnetLink`: use a magnet link to download."
      ],
      "metadata": {
        "id": "QU_WdoTH9t1E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "import os, sys, re\n",
        "import libtorrent as lt\n",
        "import ipywidgets as widgets\n",
        "from google.colab import files\n",
        "from IPython.display import display, clear_output\n",
        "\n",
        "savePath = \"\" #@param {type:\"string\"}\n",
        "downloadType = \"torrentFile\" #@param [\"torrentFile\", \"magnetLink\"]\n",
        "\n",
        "ses = lt.session()\n",
        "ses.listen_on(6881, 6891)\n",
        "downloads = []\n",
        "\n",
        "if downloadType == \"torrentFile\":\n",
        "    source = files.upload()\n",
        "    params = {\n",
        "        \"save_path\": savePath,\n",
        "        \"ti\": lt.torrent_info(list(source.keys())[0])\n",
        "    }\n",
        "    downloads.append(ses.add_torrent(params))\n",
        "    clear_output()\n",
        "else:\n",
        "    magnetLink = input(\"magnetLink: \")\n",
        "    params = {\n",
        "        \"save_path\": savePath\n",
        "    }\n",
        "    downloads.append(lt.add_magnet_uri(ses, magnetLink, params))\n",
        "    clear_output()\n",
        "\n",
        "state_str = [\n",
        "    \"queued\",\n",
        "    \"checking\",\n",
        "    \"downloading metadata\",\n",
        "    \"downloading\",\n",
        "    \"finished\",\n",
        "    \"seeding\",\n",
        "    \"allocating\",\n",
        "    \"checking fastresume\",\n",
        "]\n",
        "\n",
        "layout = widgets.Layout(width=\"auto\")\n",
        "style = {\"description_width\": \"initial\"}\n",
        "download_bars = [widgets.FloatSlider(step=0.01, disabled=True, layout=layout, style=style) for _ in downloads]\n",
        "display(*download_bars)\n",
        "\n",
        "while downloads:\n",
        "    next_shift = 0\n",
        "    for index, download in enumerate(downloads[:]):\n",
        "        bar = download_bars[index + next_shift]\n",
        "        if not download.is_seed():\n",
        "            s = download.status()\n",
        "\n",
        "            bar.description = \" \".join(\n",
        "                [\n",
        "                    download.name(),\n",
        "                    str(s.download_rate / 1000),\n",
        "                    \"kB/s\",\n",
        "                    state_str[s.state],\n",
        "                ]\n",
        "            )\n",
        "            bar.value = s.progress * 100\n",
        "        else:\n",
        "            next_shift -= 1\n",
        "            ses.remove_torrent(download)\n",
        "            downloads.remove(download)\n",
        "            bar.close() # Seems to be not working in Colab (see https://github.com/googlecolab/colabtools/issues/726#issue-486731758)\n",
        "            download_bars.remove(bar)\n",
        "            print(download.name(), \"complete\")\n",
        "    time.sleep(1)"
      ],
      "metadata": {
        "id": "qz_uuqss-Hck",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### __qBittorrent__"
      ],
      "metadata": {
        "id": "kM1Nz11l830X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to install qBittorrent to get **WEB-UI**."
      ],
      "metadata": {
        "id": "DYD9Bv3k9Cln"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/qBittorrent-Logo.svg' height=\"50\" alt=\"qBittorrent-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install qBittorrent</b></h3></center><br>\n",
        "import os\n",
        "import time\n",
        "import json\n",
        "import urllib.request\n",
        "from IPython.display import clear_output\n",
        "\n",
        "if os.path.isfile('/tools/node/bin/lt') is False:\n",
        "    !npm install -g npm\n",
        "    !npm install -g localtunnel\n",
        "else:\n",
        "    print(\"Localtunnel is already installed.\")\n",
        "\n",
        "if os.path.isfile(\"/usr/bin/qbittorrent-nox\") is False:\n",
        "    !apt update -qq -y && yes \"\" | add-apt-repository ppa:qbittorrent-team/qbittorrent-stable\n",
        "    !apt install qbittorrent-nox\n",
        "    !mkdir -p -m 666 /{content/qBittorrent,root/{.qBittorrent_temp,.config/qBittorrent}} && curl -s https://pastebin.com/raw/7TEALGNz -o /root/.config/qBittorrent/qBittorrent.conf\n",
        "    print(\"qBittorrent successfully installed.\")\n",
        "    clear_output(wait=True)\n",
        "else:\n",
        "    print(\"qBittorrent is already installed.\")\n",
        "    clear_output(wait=True)\n",
        "    !pkill qbittorrent-nox\n",
        "\n",
        "!qbittorrent-nox -d --webui-port=5454\n",
        "print(\"qBittorrent is started.\")\n",
        "clear_output(wait=True)\n",
        "!lt --port 5454"
      ],
      "metadata": {
        "cellView": "form",
        "id": "f3u7pVeD9OPe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __yt-dlp__"
      ],
      "metadata": {
        "id": "5YTskqKOBkGw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **install** yt-dlp"
      ],
      "metadata": {
        "id": "HNDzw6stBnbZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/main/cell_logos/yt-dlp-Logo.png' height=\"60\" alt=\"yt-dlp-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install yt-dlp</b></h3></center><br>\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!sudo curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /usr/local/bin/yt-dlp\n",
        "!sudo chmod a+rx /usr/local/bin/yt-dlp\n",
        "clear_output()\n",
        "!yt-dlp -U"
      ],
      "metadata": {
        "id": "iSxqbC10BqsV",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `videoLink`: YouTube and other supported website URLs are working.\n",
        "* `outputFolder`: Set the download directory.\n",
        "* `Preset`: All presets are working for YouTube URLs, but if you entering an another website's URL set `Preset: Choose Codecs`.\n",
        "> You can add formatCodes as `{video_code}+{audio_code}` to get a full output.\n",
        "* `mergeFile`: Merge final output to an another container format.\n",
        "* `viewFormats`: You can view all available formats to download.\n",
        "* Please uncheck `viewFormats` while downloading."
      ],
      "metadata": {
        "id": "v6Qd5B7SB4Bd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "videoLink = \"\" #@param {type:\"string\"}\n",
        "outputFolder = \"\" #@param {type:\"string\"}\n",
        "preset = \"Best Video + Best Audio\" #@param [\"Choose Codecs\", \"Best Video + Best Audio\", \"Best Video + Worst Audio\", \"Worst Video + Best Audio\", \"Worst Video + Worst Audio\", \"AAC Audio (140)\", \"Opus Audio (251)\", \"720p | AVC + AAC (136+140)\", \"720p | VP9 + Opus (247+251)\", \"720p | AV1 + Opus (398+251)\", \"720p60 | AVC + AAC (298+140)\", \"720p60 | VP9 + Opus (302+251)\", \"720p60 | AV1 + Opus (398+251)\", \"1080p | AVC + AAC (137+140)\", \"1080p | VP9 + Opus (248+251)\", \"1080p | AV1 + Opus (399+251)\", \"1080p60 | AVC + AAC (299+140)\", \"1080p60 | VP9 + Opus (303+251)\", \"1080p60 | AV1 + Opus (399+251)\", \"1440p | VP9 + Opus (271+251)\", \"1440p | AV1 + Opus (400+251)\", \"1440p60 | VP9 + Opus (308+251)\", \"1440p60 | AV1 + Opus (400+251)\", \"1440p60 HDR | VP9 + Opus (336+251)\", \"1440p60 HDR | AV1 + Opus (700+251)\", \"2160p (4K) | VP9 + Opus (313+251)\", \"2160p (4K) | AV1 + Opus (401+251)\", \"2160p60 (4K) | VP9 + Opus (315+251)\", \"2160p60 (4K) | AV1 + Opus (401+251)\", \"2160p60 HDR (4K) | VP9 + Opus (337+251)\", \"2160p60 HDR (4K) | AV1 + Opus (701+251)\"]\n",
        "mergeFile = \"Don't Merge\" #@param [\"Don't Merge\", \"mkv\", \"mp4\", \"ogg\", \"webm\", \"flv\"]\n",
        "viewFormats = False #@param {type:\"boolean\"}\n",
        "\n",
        "import json\n",
        "import subprocess\n",
        "\n",
        "commandLine = \"\"\n",
        "\n",
        "if not outputFolder:\n",
        "    outputFolder = \"/content/\"\n",
        "\n",
        "jsonOutput = subprocess.check_output([\n",
        "    'yt-dlp',\n",
        "    '--skip-download',\n",
        "    '-J',\n",
        "    videoLink,\n",
        "    ], stderr=subprocess.DEVNULL)\n",
        "jsonData = json.loads(jsonOutput)\n",
        "\n",
        "id = jsonData.get('id')\n",
        "title = jsonData.get('title')\n",
        "like_count = jsonData.get('like_count')\n",
        "channel = jsonData.get('channel')\n",
        "channel_follower_count = jsonData.get('channel_follower_count')\n",
        "availability = jsonData.get('availability')\n",
        "webpage_url_domain = jsonData.get('webpage_url_domain')\n",
        "extractor_key = jsonData.get('extractor_key')\n",
        "\n",
        "print(\"Extractor : \" + extractor_key)\n",
        "print(\"|\")\n",
        "print(\"|--Video ID      : \" + str(id))\n",
        "print(\"|--Video Title   : \" + str(title))\n",
        "print(\"|--Video Likes   : \" + str(like_count))\n",
        "print(\"|--Channel       : \" + str(channel))\n",
        "print(\"|--Subscribers   : \" + str(channel_follower_count))\n",
        "print(\"|--Video Status  : \" + str(availability))\n",
        "print(\"|--URL Domain    : \" + str(webpage_url_domain))\n",
        "\n",
        "if viewFormats:\n",
        "    print(' ')\n",
        "    !yt-dlp -F {videoLink}\n",
        "else:\n",
        "    if not (mergeFile == \"Don't Merge\"):\n",
        "        commandLine += f'--merge-output-format {mergeFile} '\n",
        "    if preset == \"Choose Codecs\":\n",
        "        print(' ')\n",
        "        !yt-dlp -F {videoLink}\n",
        "        formatCode = input(f'\\nformatCode: ')\n",
        "        addFormat = f'-f {formatCode}'\n",
        "    elif preset == \"Best Video + Best Audio\":\n",
        "        addFormat = \"-f bestvideo+bestaudio\"\n",
        "    elif preset == \"Best Video + Worst Audio\":\n",
        "        addFormat = \"-f bestvideo+worstaudio\"\n",
        "    elif preset == \"Worst Video + Best Audio\":\n",
        "        addFormat = \"-f worstvideo+bestaudio\"\n",
        "    elif preset == \"Worst Video + Worst Audio\":\n",
        "        addFormat = \"-f worstvideo+worstaudio\"\n",
        "    else:\n",
        "        getCode = preset.split('(')\n",
        "        getCode = getCode[1].split(')')\n",
        "        getCode = getCode[0]\n",
        "        addFormat = f'-f {getCode}'\n",
        "\n",
        "    commandLine = commandLine + addFormat + f' -P \"{outputFolder}\"'\n",
        "    commandLine = commandLine + f' {videoLink}'\n",
        "    print(' ')\n",
        "    !yt-dlp {commandLine}"
      ],
      "metadata": {
        "id": "FVPqywgiB8Ns",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __Mediainfo__"
      ],
      "metadata": {
        "id": "cPHFdW8JBarF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **get** mediainfo."
      ],
      "metadata": {
        "id": "f-g4NITYBdU1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://github.com/dropcreations/Essential-Google-Colab-Notebook/blob/main/cell_logos/Mediainfo-Logo.png?raw=true' height=\"40\" alt=\"Mediainfo-logo\"/></center>\n",
        "#@markdown <center><h3><b>Mediainfo</b></h3></center><br>\n",
        "\n",
        "mediaFile = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import os\n",
        "from IPython.display import clear_output\n",
        "\n",
        "if not os.path.isfile(\"/usr/bin/mediainfo\"):\n",
        "  !sudo apt update\n",
        "  !sudo apt install mediainfo\n",
        "  clear_output()\n",
        "\n",
        "!mediainfo \"{mediaFile}\""
      ],
      "metadata": {
        "id": "8esWDtFOBqVv",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __FFmpeg__"
      ],
      "metadata": {
        "id": "5tA84vjlBGaF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **Install** FFmpeg."
      ],
      "metadata": {
        "id": "qEq4qifxBMgG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/FFmpeg-Logo.svg' height=\"50\" alt=\"FFmpeg-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install FFmpeg</b></h3></center><br>\n",
        "from IPython.display import clear_output\n",
        "!sudo curl -L https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz -o /usr/local/bin/ffmpeg.tar.xz\n",
        "clear_output()\n",
        "%cd /usr/local/bin/\n",
        "clear_output()\n",
        "!7z e -y /usr/local/bin/ffmpeg.tar.xz\n",
        "clear_output()\n",
        "!7z e -y /usr/local/bin/ffmpeg.tar\n",
        "clear_output()\n",
        "!sudo chmod a+rx /usr/local/bin/ffmpeg\n",
        "clear_output()\n",
        "%cd /content/\n",
        "clear_output()\n",
        "!ffmpeg -version"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Ydt-FHW9BRsT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Remux Video files__"
      ],
      "metadata": {
        "id": "NA8FedFWEBzp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* **REMUX** video files without **RE-ENCODING**.\n",
        "* Make sure that `outputFormat` that you have selected is supported for all tracks in the `inputFile`.\n",
        "* `WebM` only support `VP9`, `VP8`, `AV1` video and `Vorbis`, `Opus` audio and `WebVTT` subtitles."
      ],
      "metadata": {
        "id": "i8lt6yVBBkMF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "outputFormat = \"mp4\" #@param [\"mp4\", \"mkv\", \"mov\", \"webm\"]\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = '-hide_banner -i \"' + inputFile + '\" -map 0:v? -c:v copy -map 0:a? -c:a copy '\n",
        "\n",
        "if outputFormat == \"mp4\" or outputFormat == \"mov\":\n",
        "    commandLine = commandLine + '-map 0:s? -c:s mov_text -movflags +faststart '\n",
        "elif outputFormat == \"webm\":\n",
        "    commandLine = commandLine + '-map 0:s? -c:s webvtt '\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + '.' + outputFormat))\n",
        "    if os.path.isfile(outputFile):\n",
        "        outputFile = os.path.join(sourceFolder, (sourceName + '_[REMUX].' + outputFormat))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + '.' + outputFormat))\n",
        "    if os.path.isfile(outputFile):\n",
        "        outputFile = os.path.join(outputFolder, (sourceName + '_[REMUX].' + outputFormat))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "\n",
        "!ffmpeg {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "UsNnwjF8BsnM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Trim Video Files__"
      ],
      "metadata": {
        "id": "woyL8n68EKbH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* **TRIM** video files without **RE-ENCODING**.\n",
        "* `inputFile`: video file's path and set `startTime` and `endTime` to trim.\n",
        "* Trimed video will be saved as same as the **source's format**."
      ],
      "metadata": {
        "id": "mAMzYj9zCy7r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "startTime = \"00:00:00.000\" #@param {type:\"string\"}\n",
        "endTime = \"00:00:00.000\" #@param {type:\"string\"}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "commandLine = '-hide_banner -i \"' + inputFile + '\" -map 0 -c copy -ss ' + startTime + ' -to ' + endTime + ' '\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceExtention = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[1]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + f'_[{startTime}-{endTime}]' + sourceExtention))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + f'_[{startTime}-{endTime}]' + sourceExtention))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "\n",
        "!ffmpeg {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "10kZ-bwsCwcT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Extract Audio__"
      ],
      "metadata": {
        "id": "isT4DWI4EOUX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* **EXTRACT** audio tracks from video files.\n",
        "* `DTS`, `DTS-HD`, `DTS-MA`, `TrueHD` tracks will be muxed as a `.mka` file."
      ],
      "metadata": {
        "id": "BDxWJan3DJih"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import json\n",
        "import subprocess\n",
        "import prettytable\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "jsonFFprobe = subprocess.check_output([\n",
        "    'ffprobe',\n",
        "    '-hide_banner',\n",
        "    '-loglevel',\n",
        "    'warning',\n",
        "    '-print_format',\n",
        "    'json',\n",
        "    '-show_entries',\n",
        "    'stream',\n",
        "    '-i',\n",
        "    os.path.abspath(inputFile),\n",
        "    ], stderr=subprocess.DEVNULL)\n",
        "jsonData = json.loads(jsonFFprobe)\n",
        "\n",
        "streamCount = len(jsonData['streams'])\n",
        "commandLine = '-hide_banner -i \"' + inputFile + '\" '\n",
        "\n",
        "codecTable = prettytable.PrettyTable()\n",
        "codecTable.field_names = ['Track ID', 'Codec name', 'Channels', 'Sample rate']\n",
        "codecTable.align = 'l'\n",
        "\n",
        "for i in range(streamCount):\n",
        "    codec_type = jsonData.get('streams')[int(i)].get('codec_type')\n",
        "    if codec_type == \"audio\":\n",
        "        index = jsonData.get('streams')[int(i)].get('index')\n",
        "        codec_name = jsonData.get('streams')[int(i)].get('codec_name')\n",
        "        channel_layout = jsonData.get('streams')[int(i)].get('channels')\n",
        "        sample_rate = jsonData.get('streams')[int(i)].get('sample_rate')\n",
        "        codecTable.add_row([index, codec_name, channel_layout, sample_rate])\n",
        "\n",
        "stringTable = '\\t' + codecTable.__str__().replace('\\n', '\\n\\t')\n",
        "print(stringTable)\n",
        "\n",
        "trackID = input(\"\\ntrackID: \")\n",
        "codec_name = jsonData.get('streams')[int(trackID)].get('codec_name')\n",
        "if \"opus\" in codec_name:\n",
        "    codec_ext = \"ogg\"\n",
        "elif \"dts\" in codec_name:\n",
        "    codec_ext = \"mka\"\n",
        "elif \"aac\" in codec_name:\n",
        "    codec_ext = \"aac\"\n",
        "elif \"truehd\" in codec_name:\n",
        "    codec_ext = \"mka\"\n",
        "elif codec_name == \"ac3\":\n",
        "    codec_ext = \"ac3\"\n",
        "elif codec_name == \"eac3\":\n",
        "    codec_ext = \"eac3\"\n",
        "elif \"pcm\" in codec_name:\n",
        "    codec_ext = \"wav\"\n",
        "elif \"flac\" in codec_name:\n",
        "    codec_ext = \"flac\"\n",
        "\n",
        "commandLine = commandLine + \"-vn -sn -map 0:\" + str(trackID) + \" -c copy \"\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + f'_[{codec_name}].' + codec_ext))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + f'_[{codec_name}].' + codec_ext))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "\n",
        "!ffmpeg {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "IMCyqX3JDeCJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Remove Bitstream Metadata__"
      ],
      "metadata": {
        "id": "-eA_TTaeW5Or"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* For `H.264`/`AVC` tracks run below cell."
      ],
      "metadata": {
        "id": "CUUdTnN4W9KS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import json\n",
        "import subprocess\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "jsonFFprobe = subprocess.check_output([\n",
        "    'ffprobe',\n",
        "    '-hide_banner',\n",
        "    '-loglevel',\n",
        "    'warning',\n",
        "    '-print_format',\n",
        "    'json',\n",
        "    '-show_entries',\n",
        "    'stream',\n",
        "    '-i',\n",
        "    os.path.abspath(inputFile),\n",
        "    ], stderr=subprocess.DEVNULL)\n",
        "jsonData = json.loads(jsonFFprobe)\n",
        "\n",
        "streamCount = len(jsonData['streams'])\n",
        "commandLine = '-hide_banner -i \"' + inputFile + '\" '\n",
        "\n",
        "for i in range(streamCount):\n",
        "    codec_name = jsonData.get('streams')[int(i)].get('codec_name')\n",
        "    if codec_name == \"h264\":\n",
        "        index = jsonData.get('streams')[int(i)].get('index')\n",
        "        commandLine = commandLine + f'-map 0:{index} '\n",
        "\n",
        "commandLine = commandLine + '-c:v copy -map 0:a? -c:a copy -map 0:s? -c:s copy -bitexact -map_metadata -1 -vbsf filter_units=remove_types=6 '\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceExtention = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[1]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + f'_[NEW]' + sourceExtention))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + f'_[NEW]' + sourceExtention))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "\n",
        "!ffmpeg {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "42RngSK7XAV9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* For `H.265`/`HEVC` tracks run below cell."
      ],
      "metadata": {
        "id": "uLytCUgXXFB7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import json\n",
        "import subprocess\n",
        "from IPython.display import clear_output\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "if not os.path.isfile('/usr/local/bin/mkvmerge'):\n",
        "    !sudo curl -L https://mkvtoolnix.download/appimage/MKVToolNix_GUI-68.0.0-x86_64.AppImage -o /usr/local/bin/MKVToolNix_GUI-68.0.0-x86_64.AppImage\n",
        "    !sudo chmod u+rx /usr/local/bin/MKVToolNix_GUI-68.0.0-x86_64.AppImage\n",
        "    !sudo ln -s /usr/local/bin/MKVToolNix_GUI-68.0.0-x86_64.AppImage /usr/local/bin/mkvmerge\n",
        "    !sudo chmod a+rx /usr/local/bin/mkvmerge\n",
        "    clear_output()\n",
        "\n",
        "jsonFFprobe = subprocess.check_output([\n",
        "    'ffprobe',\n",
        "    '-hide_banner',\n",
        "    '-loglevel',\n",
        "    'warning',\n",
        "    '-print_format',\n",
        "    'json',\n",
        "    '-show_entries',\n",
        "    'stream',\n",
        "    '-i',\n",
        "    os.path.abspath(inputFile),\n",
        "    ], stderr=subprocess.DEVNULL)\n",
        "jsonData = json.loads(jsonFFprobe)\n",
        "\n",
        "streamCount = len(jsonData['streams'])\n",
        "commandLine = f'-hide_banner -i \"{inputFile}\" '\n",
        "tracksALL = []\n",
        "tracksHEVC = []\n",
        "\n",
        "for i in range(streamCount):\n",
        "    indexALL = jsonData.get('streams')[int(i)].get('index')\n",
        "    tracksALL.append(indexALL)\n",
        "    codec_name = jsonData.get('streams')[int(i)].get('codec_name')\n",
        "    if codec_name == \"hevc\":\n",
        "        index = jsonData.get('streams')[int(i)].get('index')\n",
        "        tracksHEVC.append(index)\n",
        "\n",
        "commandLine = commandLine + f'-map 0:{tracksHEVC[0]} -c:v copy -an -sn -vbsf hevc_mp4toannexb /content/source-video.hevc && ffmpeg -hide_banner -i /content/source-video.hevc -c copy -vbsf filter_units=remove_types=39 /content/output.hevc && mkvmerge --output /content/output.mkv /content/output.hevc && ffmpeg -hide_banner -i /content/output.mkv -i \"{inputFile}\" -map 0:0 '\n",
        "for trackID in tracksALL:\n",
        "    if trackID != tracksHEVC[0]:\n",
        "        commandLine = commandLine + f'-map 1:{trackID} '\n",
        "commandLine = commandLine + f'-c copy '\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceExtention = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[1]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + f'_[NEW]' + sourceExtention))\n",
        "    commandLine = commandLine + f'\"{outputFile}\"'\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + f'_[NEW]' + sourceExtention))\n",
        "    commandLine = commandLine + f'\"{outputFile}\"'\n",
        "\n",
        "!ffmpeg {commandLine}\n",
        "!rm /content/source-video.hevc\n",
        "!rm /content/output.hevc\n",
        "!rm /content/output.mkv"
      ],
      "metadata": {
        "cellView": "form",
        "id": "r-wTfP-uXJW8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Encode H.264__"
      ],
      "metadata": {
        "id": "RUljam4skvZm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* `CRF` and `2-Pass` encoding available.\n",
        "* This cell only encodes the **first video track** from the input file."
      ],
      "metadata": {
        "id": "W91D89g7k7j7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputFile = \"\"  #@param {type:\"string\"}\n",
        "encodeMode = \"CRF\" #@param [\"CRF\", \"2-Pass\"]\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "#@markdown ### __CRF Settings__\n",
        "crf = 19 #@param {type:\"slider\", min:0, max:51, step:1}\n",
        "#@markdown ### __2-Pass Settings__\n",
        "Bitrate = \"5800\" #@param {type:\"string\"}\n",
        "#@markdown ### __General Settings__\n",
        "Preset = \"veryslow\" #@param [\"ultrafast\", \"superfast\", \"veryfast\", \"faster\", \"fast\", \"medium\", \"slow\", \"slower\", \"veryslow\", \"placebo\"]\n",
        "Profile = \"high\" #@param [\"baseline\", \"main\", \"high\", \"high10\", \"high422\", \"high444\"]\n",
        "Level = \"4\" #@param [\"1\", \"1.1\", \"1.2\", \"1.3\", \"2\", \"2.1\", \"2.2\", \"3\", \"3.1\",\"3.2\", \"4\", \"4.1\", \"4.2\", \"5\", \"5.1\", \"5.2\"]\n",
        "bitDepth = \"8-Bit\" #@param [\"8-Bit\", \"10-Bit\"]\n",
        "Tune = \"None\" #@param [\"None\", \"film\", \"animation\", \"grain\", \"stillimage\", \"psnr\", \"ssim\", \"fastdecode\", \"zerolatency\"]\n",
        "Maxrate = \"8700\" #@param {type:\"string\"}\n",
        "Bufsize = \"11600\" #@param {type:\"string\"}\n",
        "\n",
        "import os\n",
        "\n",
        "commandLine = f'-preset {Preset} -profile:v {Profile} -level {Level} -maxrate {Maxrate}k -bufsize {Bufsize}k '\n",
        "\n",
        "if Tune != \"None\":\n",
        "    commandLine = commandLine + f'-tune {Tune} '\n",
        "if bitDepth == \"8-Bit\":\n",
        "    commandLine = commandLine + f'-pix_fmt yuv420p '\n",
        "elif bitDepth == \"10-Bit\":\n",
        "    commandLine = commandLine + f'-pix_fmt yuv420p10le '\n",
        "\n",
        "commandLine = commandLine + f'-partitions all -me_range 24 -nal-hrd 1 -sc_threshold 0 -x264-params \"colorprim=bt709:colormatrix=bt709:transfer=bt709:qpmin=6:qpmax=51:bframes=4:lookahead-threads=2:stitchable=1\"'\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceExtention = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[1]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + f'_[Encoded]' + sourceExtention))\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + f'_[Encoded]' + sourceExtention))\n",
        "\n",
        "firstPass = f'-hide_banner -i \"{os.path.abspath(inputFile)}\" -map 0:v:0 -c:v libx264 -pass 1 -b:v {Bitrate}k {commandLine} -an -sn -y -f null /dev/null'\n",
        "secondPass = f'-hide_banner -i \"{os.path.abspath(inputFile)}\" -map 0:v:0 -c:v libx264 -pass 2 -b:v {Bitrate}k {commandLine} -map 0:a? -c:a copy -map 0:s? -c:s copy \"{outputFile}\"'\n",
        "crfPass = f'-hide_banner -i \"{os.path.abspath(inputFile)}\" -map 0:v:0 -c:v libx264 -crf {crf} {commandLine} -map 0:a? -c:a copy -map 0:s? -c:s copy \"{outputFile}\"'\n",
        "\n",
        "if encodeMode == 'CRF':\n",
        "    !ffmpeg {crfPass}\n",
        "else:\n",
        "    !ffmpeg {firstPass}\n",
        "    !ffmpeg {secondPass}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "fqTzSnwoZdXj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __HDR to SDR__"
      ],
      "metadata": {
        "id": "5mDj5RJq9Yan"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Convert `HDR` video to `SDR` video.\n",
        "* `toneMap`: Select tone mapping method."
      ],
      "metadata": {
        "id": "g-TaIrq89a2m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "Codec = \"HEVC\" #@param [\"H.264\", \"HEVC\"]\n",
        "valueCRF = 22 #@param {type:\"slider\", min:0, max:51, step:1}\n",
        "bitDepth = \"10-Bit\" #@param [\"8-Bit\", \"10-Bit\"]\n",
        "toneMap = \"hable\" #@param [\"none\", \"clip\", \"linear\", \"gamma\", \"reinhard\", \"hable\", \"mobius\"]\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "if Codec == \"H.264\":\n",
        "  Codec = \"libx264\"\n",
        "elif Codec == \"HEVC\":\n",
        "  Codec = \"libx265\"\n",
        "\n",
        "if bitDepth == \"8-Bit\":\n",
        "    bitDepth = \"yuv420p\"\n",
        "elif bitDepth == \"10-Bit\":\n",
        "    bitDepth = \"yuv420p10le\"\n",
        "\n",
        "commandLine = f'-hide_banner -i \"{inputFile}\" -max_muxing_queue_size 1024 -c:v {Codec} -crf:v {valueCRF} -preset:v medium -pix_fmt {bitDepth} '\n",
        "\n",
        "if Codec == \"libx265\":\n",
        "    commandLine = commandLine + f'-x265-params \"aq-mode=2:repeat-headers=0:strong-intra-smoothing=1:bframes=4:b-adapt=2:frame-threads=0\" '\n",
        "commandLine = commandLine + f'-vf zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap={toneMap}:desat=0,zscale=t=bt709:m=bt709:r=tv,format={bitDepth} -map 0:a? -c:a copy -map 0:s? -c:s copy '\n",
        "\n",
        "sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "sourceExtention = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[1]\n",
        "sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "if saveToSourceLocation:\n",
        "    outputFile = os.path.join(sourceFolder, (sourceName + f'_[SDR]' + sourceExtention))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "else:\n",
        "    outputFolder = input(\"outputFolder: \")\n",
        "    outputFile = os.path.join(outputFolder, (sourceName + f'_[SDR]' + sourceExtention))\n",
        "    commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "\n",
        "!ffmpeg {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "RXwGLW_G9dt_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __HDR10 Encoding__"
      ],
      "metadata": {
        "id": "KZD2o35r9h9I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Only `x265`/`HEVC` tracks are supported.\n",
        "* `extractColors`: View the color information of the footage.\n",
        "* When encoding, make sure `extractColors` is **deselected**."
      ],
      "metadata": {
        "id": "kTujKDbM9kKl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import json\n",
        "import subprocess\n",
        "\n",
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "preset = \"slow\" #@param [\"ultrafast\", \"superfast\", \"veryfast\", \"faster\", \"fast\", \"medium\", \"slow\", \"slower\", \"veryslow\", \"placebo\"]\n",
        "profile = \"main10\" #@param [\"main\", \"main10\"]\n",
        "level = \"4\" #@param [\"1\", \"1.1\", \"1.2\", \"1.3\", \"2\", \"2.1\", \"2.2\", \"3\", \"3.1\",\"3.2\", \"4\", \"4.1\", \"4.2\", \"5\", \"5.1\", \"5.2\"]\n",
        "valueCRF = 19 #@param {type:\"slider\", min:0, max:51, step:1}\n",
        "extractColors = False #@param {type:\"boolean\"}\n",
        "saveToSourceLocation = True #@param {type:\"boolean\"}\n",
        "\n",
        "jsonFFprobe = subprocess.check_output([\n",
        "    'ffprobe', '-hide_banner', '-loglevel', 'warning',\n",
        "    '-print_format', 'json', '-show_frames', '-read_intervals', '%+#1', '-show_entries',\n",
        "    'format:stream:frame=color_space,color_primaries,color_transfer,side_data_list,pix_fmt',\n",
        "    '-i', os.path.abspath(inputFile)], stderr=subprocess.DEVNULL)\n",
        "jsonData = json.loads(jsonFFprobe)\n",
        "\n",
        "pix_fmt = jsonData.get('frames')[0].get('pix_fmt')\n",
        "\n",
        "if jsonData.get('frames')[0].get('color_space'):\n",
        "    color_space = jsonData.get('frames')[0].get('color_space')\n",
        "if jsonData.get('frames')[0].get('color_primaries'):\n",
        "    color_primaries = jsonData.get('frames')[0].get('color_primaries')\n",
        "if jsonData.get('frames')[0].get('color_transfer'):\n",
        "    color_transfer = jsonData.get('frames')[0].get('color_transfer')\n",
        "if jsonData.get('frames')[0].get('side_data_list'):\n",
        "    side_data_list = jsonData.get('frames')[0].get('side_data_list')[0]\n",
        "\n",
        "    red_x = round(eval(side_data_list.get('red_x', '0')), 4)\n",
        "    red_y = round(eval(side_data_list.get('red_y', '0')), 4)\n",
        "    green_x = round(eval(side_data_list.get('green_x', '0')), 4)\n",
        "    green_y = round(eval(side_data_list.get('green_y', '0')), 4)\n",
        "    blue_x = round(eval(side_data_list.get('blue_x', '0')), 4)\n",
        "    blue_y = round(eval(side_data_list.get('blue_y', '0')), 4)\n",
        "    white_point_x = round(eval(side_data_list.get('white_point_x', '0')), 4)\n",
        "    white_point_y = round(eval(side_data_list.get('white_point_y', '0')), 4)\n",
        "    min_luminance = round(eval(side_data_list.get('min_luminance', '0')), 4)\n",
        "    max_luminance = round(eval(side_data_list.get('max_luminance', '0')), 4)\n",
        "\n",
        "    cll_max_content = 0\n",
        "    cll_max_average = 0\n",
        "\n",
        "    try:\n",
        "        side_data_list = jsonData.get('frames')[0].get('side_data_list')[1]\n",
        "        cll_max_content = round(eval(str(side_data_list.get('max_content', '0'))), 4)\n",
        "        cll_max_average = round(eval(str(side_data_list.get('max_average', '0'))), 4)\n",
        "    except:\n",
        "        pass\n",
        "\n",
        "    x265_red_x = round(red_x / 0.00002)\n",
        "    x265_red_y = round(red_y / 0.00002)\n",
        "    x265_green_x = round(green_x / 0.00002)\n",
        "    x265_green_y = round(green_y / 0.00002)\n",
        "    x265_blue_x = round(blue_x / 0.00002)\n",
        "    x265_blue_y = round(blue_y / 0.00002)\n",
        "    x265_white_point_x = round(white_point_x / 0.00002)\n",
        "    x265_white_point_y = round(white_point_y / 0.00002)\n",
        "    x265_min_luminance = round(min_luminance / 0.0001)\n",
        "    x265_max_luminance = round(max_luminance / 0.0001)\n",
        "\n",
        "    x265_master_display_info = 'G(' + str(x265_green_x) + ',' + str(x265_green_y) + ')B(' \\\n",
        "        + str(x265_blue_x) + ',' + str(x265_blue_y) + ')R(' + str(x265_red_x) + ',' \\\n",
        "        + str(x265_red_y) + ')WP(' + str(x265_white_point_x) + ',' \\\n",
        "        + str(x265_white_point_y) + ')L(' + str(x265_max_luminance) + ',' \\\n",
        "        + str(x265_min_luminance) + '):max-cll=' + str(cll_max_content) \\\n",
        "        + ',' + str(cll_max_average)\n",
        "\n",
        "commandLine = f'-hide_banner -i \"{os.path.abspath(inputFile)}\" -map 0:v -c:v libx265 -crf {valueCRF} -preset {preset} '\n",
        "\n",
        "if pix_fmt == \"rgb24\":\n",
        "    print(\"You have selected a Non-HDR footage....\")\n",
        "else:\n",
        "    if extractColors:\n",
        "        if jsonData.get('frames')[0].get('color_space'):\n",
        "            print(\"color_space: \\t\\t\" + color_space)\n",
        "        if jsonData.get('frames')[0].get('color_primaries'):\n",
        "            print(\"color_primaries: \\t\" + color_primaries)\n",
        "        if jsonData.get('frames')[0].get('color_transfer'):\n",
        "            print(\"color_transfer: \\t\" + color_transfer)\n",
        "        if jsonData.get('frames')[0].get('side_data_list'):\n",
        "            print(\"master_display:\\t\\t\" + x265_master_display_info)\n",
        "    else:\n",
        "        if profile == \"main\":\n",
        "            commandLine = commandLine + f'-profile:v main -pix_fmt yuv420p '\n",
        "        elif profile == \"main10\":\n",
        "            commandLine = commandLine + f'-profile:v main10 -pix_fmt yuv420p10le '\n",
        "        if jsonData.get('frames')[0].get('side_data_list'):\n",
        "            commandLine = commandLine + f'-x265-params \"level-idc={level}:aq-mode=2:no-info=1:strong-intra-smoothing=1:bframes=4:b-adapt=2:frame-threads=0:hdr10=1:chromaloc=2:repeat-headers=1:aud=1:hrd=1:colorprim={color_primaries}:colormatrix={color_space}:transfer={color_transfer}:range=limited:master-display={x265_master_display_info}\" '\n",
        "        else:\n",
        "            commandLine = commandLine + f'-x265-params \"level-idc={level}:aq-mode=2:no-info=1:strong-intra-smoothing=1:bframes=4:b-adapt=2:frame-threads=0:chromaloc=2:repeat-headers=1:colorprim={color_primaries}:colormatrix={color_space}:transfer={color_transfer}:range=limited\" '\n",
        "        commandLine = commandLine + f'-map 0:a? -c:a copy -map 0:s? -c:s copy '\n",
        "\n",
        "        sourceName = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]\n",
        "        sourceExtention = os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[1]\n",
        "        sourceFolder = os.path.dirname(os.path.abspath(inputFile))\n",
        "\n",
        "        if saveToSourceLocation:\n",
        "            outputFile = os.path.join(sourceFolder, (sourceName + f'_[HDR]' + sourceExtention))\n",
        "            commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "        else:\n",
        "            outputFolder = input(\"outputFolder: \")\n",
        "            outputFile = os.path.join(outputFolder, (sourceName + f'_[HDR]' + sourceExtention))\n",
        "            commandLine = commandLine + '\"' + outputFile + '\"'\n",
        "\n",
        "        !ffmpeg {commandLine}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "l4dLjekJ9nq1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __H.264 Encoder__"
      ],
      "metadata": {
        "id": "T0OKhZu-Z2ot"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* This encodes **video track** only.\n",
        "* Use ffmpeg or any other to **merge** video with audios.\n",
        "* Run below cell to **install** x264."
      ],
      "metadata": {
        "id": "ggb36qLyaZM7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://github.com/dropcreations/Essential-Google-Colab-Notebook/blob/main/cell_logos/x264-Logo.png?raw=true' height=\"40\" alt=\"x264-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install x264 Encoder</b></h3></center><br>\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!sudo curl -L https://artifacts.videolan.org/x264/release-debian-amd64/x264-r3164-c196240 -o /usr/local/bin/x264\n",
        "!sudo chmod a+rx /usr/local/bin/x264\n",
        "clear_output()\n",
        "!x264 --version"
      ],
      "metadata": {
        "id": "nc1ce9zcXM4J",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Set `inputFile` and `outputFolder`.\n",
        "* This cell is taking the output name as same as the input filename. So, you need to set the output folder only.\n",
        "* Change **settings** as you want."
      ],
      "metadata": {
        "id": "SgMhT8eUbBXk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputFile = \"\"  #@param {type:\"string\"}\n",
        "outputFolder = \"\"  #@param {type:\"string\"}\n",
        "outputFormat = \"MKV\" #@param [\"RAW\", \"MKV\", \"FLV\", \"MP4\"]\n",
        "encodeMode = \"CRF\" #@param [\"CRF\", \"2-Pass\"]\n",
        "#@markdown ###__CRF Settings__\n",
        "crf = 19 #@param {type:\"slider\", min:0, max:51, step:1}\n",
        "#@markdown ###__2-Pass Settings__\n",
        "Bitrate = \"5800\" #@param {type:\"string\"}\n",
        "#@markdown ###__General Settings__\n",
        "Preset = \"veryslow\" #@param [\"ultrafast\", \"superfast\", \"veryfast\", \"faster\", \"fast\", \"medium\", \"slow\", \"slower\", \"veryslow\", \"placebo\"]\n",
        "Profile = \"high\" #@param [\"baseline\", \"main\", \"high\", \"high10\", \"high422\", \"high444\"]\n",
        "bitDepth = \"8-bit\" #@param [\"8-bit\", \"10-bit\"]\n",
        "Level = \"4\" #@param [\"1\", \"1.1\", \"1.2\", \"1.3\", \"2\", \"2.1\", \"2.2\", \"3\", \"3.1\",\"3.2\", \"4\", \"4.1\", \"4.2\", \"5\", \"5.1\", \"5.2\"]\n",
        "Tune = \"None\" #@param [\"None\", \"film\", \"animation\", \"grain\", \"stillimage\", \"psnr\", \"ssim\", \"fastdecode\", \"zerolatency\"]\n",
        "vbvMaxrate = \"8700\" #@param {type:\"string\"}\n",
        "vbvBufsize = \"11200\" #@param {type:\"string\"}\n",
        "frameRate = \"Automatic\" #@param [\"Automatic\", \"24000/1001\", \"24\", \"25\", \"30000/1001\", \"30\", \"50\", \"60000/1001\", \"60\"]\n",
        "qpMin = 6 #@param {type:\"slider\", min:0, max:69, step:1}\n",
        "qpMax = 51 #@param {type:\"slider\", min:0, max:69, step:1}\n",
        "meRange = 24 #@param {type:\"integer\"}\n",
        "bFrames = 4 #@param {type:\"integer\"}\n",
        "Lookahead = 48 #@param {type:\"integer\"}\n",
        "refFrames = 4 #@param {type:\"integer\"}\n",
        "Scenecut = 40 #@param {type:\"integer\"}\n",
        "keyintMax = 250 #@param {type:\"integer\"}\n",
        "keyintMin = 24 #@param {type:\"integer\"}\n",
        "videoFormat = \"Undefined\" #@param [\"Undefined\", \"component\", \"pal\", \"ntsc\", \"secam\", \"mac\"]\n",
        "colorPrim = \"bt709\" #@param [\"Undefined\", \"bt2020\", \"bt470bg\", \"bt470m\", \"bt709\", \"film\", \"smpte170m\", \"smpte240m\", \"smpte428\", \"smpte431\", \"smpte432\"]\n",
        "colorMatrix = \"bt709\" #@param [\"Undefined\", \"bt2020c\", \"bt2020nc\", \"bt470bg\", \"bt709\", \"fcc\", \"gbr\", \"smpte170m\", \"smpte2085\", \"smpte240m\", \"ycgco\", \"chromaderivedc\", \"ictcp\"]\n",
        "Transfer = \"bt709\" #@param [\"Undefined\", \"bt1361e\", \"bt2020-10\", \"bt2020-12\", \"bt470bg\", \"bt470m\", \"bt709\", \"iec61966-2-1\", \"iec61966-2-4\", \"linear\", \"log100\", \"log316\", \"smpte170m\", \"smpte2084\", \"smpte240m\", \"smpte428\"]\n",
        "Range = \"Auto\" #@param [\"Auto\", \"tv\", \"pc\"]\n",
        "signalHRDinfo = \"vbr\" #@param [\"None\", \"vbr\", \"cbr\"]\n",
        "Chromaloc = 0 #@param {type:\"integer\"}\n",
        "threadsCount = 0 #@param {type:\"integer\"}\n",
        "lookaheadThreads = 0 #@param {type:\"integer\"}\n",
        "customCommands = \"\" #@param {type:\"string\"}\n",
        "fastpskip = True #@param {type:\"boolean\"}\n",
        "Stitchable = True #@param {type:\"boolean\"}\n",
        "\n",
        "import os\n",
        "\n",
        "if bitDepth == \"8-bit\":\n",
        "    bitDepth = \"8\"\n",
        "elif bitDepth == \"10-bit\":\n",
        "    bitDepth = \"10\"\n",
        "\n",
        "if encodeMode == 'CRF':\n",
        "    commandLine = f'--crf {crf} '\n",
        "else:\n",
        "    commandLine = f'--bitrate {Bitrate} '\n",
        "\n",
        "commandLine = commandLine + f'--preset {Preset} --output-depth {bitDepth} --profile {Profile} --level {Level} --partitions all --qpmin {qpMin} --qpmax {qpMax} '\n",
        "\n",
        "if Tune != \"None\":\n",
        "    commandLine = commandLine + f'--tune {Tune} '\n",
        "if vbvMaxrate != \"\":\n",
        "    commandLine = commandLine + f'--vbv-maxrate {vbvMaxrate} '\n",
        "if vbvBufsize != \"\":\n",
        "    commandLine = commandLine + f'--vbv-bufsize {vbvBufsize} '\n",
        "if frameRate != \"Automatic\":\n",
        "    commandLine = commandLine + f'--fps {frameRate} '\n",
        "if meRange != \"\":\n",
        "    commandLine = commandLine + f'--merange {meRange} '\n",
        "if bFrames != 0:\n",
        "    commandLine = commandLine + f'--bframes {bFrames} '\n",
        "if Lookahead != 0:\n",
        "    commandLine = commandLine + f'--rc-lookahead {Lookahead} '\n",
        "if refFrames != 0:\n",
        "    commandLine = commandLine + f'--ref {refFrames} '\n",
        "if Scenecut != 40:\n",
        "    commandLine = commandLine + f'--scenecut {Scenecut} '\n",
        "if keyintMax != 250:\n",
        "    commandLine = commandLine + f'--keyint {keyintMax} '\n",
        "if keyintMin != 0:\n",
        "    commandLine = commandLine + f'--min-keyint {keyintMin} '\n",
        "if videoFormat != \"Undefined\":\n",
        "    commandLine = commandLine + f'--videoformat {videoFormat} '\n",
        "if colorPrim != \"Undefined\":\n",
        "    commandLine = commandLine + f'--colorprim {colorPrim} '\n",
        "if colorMatrix != \"Undefined\":\n",
        "    commandLine = commandLine + f'--colormatrix {colorMatrix} '\n",
        "if Transfer != \"Undefined\":\n",
        "    commandLine = commandLine + f'--transfer {Transfer} '\n",
        "if Range != \"Auto\":\n",
        "    commandLine = commandLine + f'--range {Range} '\n",
        "if signalHRDinfo != \"None\":\n",
        "    commandLine = commandLine + f'--nal-hrd {signalHRDinfo} '\n",
        "if Chromaloc != 0:\n",
        "    commandLine = commandLine + f'--chromaloc {Chromaloc} '\n",
        "if threadsCount != 0:\n",
        "    commandLine = commandLine + f'--threads {threadsCount} '\n",
        "if lookaheadThreads != 0:\n",
        "    commandLine = commandLine + f'--lookahead-threads {lookaheadThreads} '\n",
        "if not fastpskip:\n",
        "    commandLine = commandLine + f'--no-fast-pskip '\n",
        "if Stitchable:\n",
        "    commandLine = commandLine + f'--stitchable '\n",
        "if customCommands != \"\":\n",
        "    commandLine = commandLine + f'{customCommands} '\n",
        "\n",
        "firstPass = f'--pass 1 {commandLine}--stats /tmp/x264_stats_out.stats --output NUL'\n",
        "\n",
        "if outputFormat == \"RAW\":\n",
        "    outputName = f'{os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]}.264'\n",
        "elif outputFormat == \"MKV\":\n",
        "    outputName = f'{os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]}.mkv'\n",
        "elif outputFormat == \"FLV\":\n",
        "    outputName = f'{os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]}.flv'\n",
        "elif outputFormat == \"MP4\":\n",
        "    outputName = f'{os.path.splitext(os.path.basename(os.path.abspath(inputFile)))[0]}.mp4'\n",
        "outputPath = os.path.join(outputFolder, outputName)\n",
        "\n",
        "secondPass = f'--pass 2 {commandLine}--stats /tmp/x264_stats_out.stats \"{outputPath}\" \"{inputFile}\"'\n",
        "crfPass = f'{commandLine}\"{outputPath}\" \"{inputFile}\"'\n",
        "\n",
        "if encodeMode == 'CRF':\n",
        "    !x264 {crfPass}'\n",
        "else:\n",
        "    !x264 {firstPass}'\n",
        "    !x264 {secondPass}'"
      ],
      "metadata": {
        "cellView": "form",
        "id": "mL0FEcf6XTAp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __MP4Box__"
      ],
      "metadata": {
        "id": "FniVYlndAJCC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **install** MP4Box."
      ],
      "metadata": {
        "id": "1O3y2L1yAMpY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/main/cell_logos/GPAC-Logo.png' height=\"60\" alt=\"gpac-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install MP4Box</b></h3></center><br>\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!echo \"deb http://security.ubuntu.com/ubuntu focal-security main\" | sudo tee /etc/apt/sources.list.d/focal-security.list\n",
        "!sudo apt-get update\n",
        "!sudo apt-get install libssl1.1\n",
        "!sudo curl -L https://download.tsi.telecom-paristech.fr/gpac/release/2.2.1/gpac_2.2.1-rev0-gb34e3851-release-2.2_amd64.deb -o /usr/bin/gpac.deb\n",
        "!sudo apt install /usr/bin/gpac.deb\n",
        "clear_output()\n",
        "!MP4Box -version"
      ],
      "metadata": {
        "id": "FpZia2y8Aa_g",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Create MP4/M4A Files__"
      ],
      "metadata": {
        "id": "cW8Zx97aMELg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Enter **tracks** while running the cell.\n",
        "* Tracks must be in **raw format**. `(eg: .h264, .hevc, .aac, .eac3,....)`\n",
        "* If you don't want to add **track title** and **track language** leave them blank."
      ],
      "metadata": {
        "id": "t5aKuC78MHyH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "outputFolder = \"\" #@param {type:\"string\"}\n",
        "outputFormat = \"mp4\" #@param [\"mp4\", \"m4a\"]\n",
        "viewLanguageCodes = False #@param {type:\"boolean\"}\n",
        "\n",
        "if not outputFolder:\n",
        "    outputFolder = \"/content/\"\n",
        "\n",
        "inputLine = []\n",
        "inputList = []\n",
        "\n",
        "inputFile = \"\"\n",
        "inputParams = \"\"\n",
        "commandLine = \"\"\n",
        "\n",
        "if not viewLanguageCodes:\n",
        "    while True:\n",
        "        inputFile = input(\"\\ninputTrack: \")\n",
        "        if not inputFile: break\n",
        "        inputList.append(inputFile)\n",
        "\n",
        "        trackType = int(input(f'|\\n|-- 1 : Video\\n|-- 2 : Audio\\n|-- 3 : Subtitle\\n|\\n|--trackType: [1/2/3] '))\n",
        "\n",
        "        if trackType == 1:\n",
        "            trackType = f'#video'\n",
        "        elif trackType == 2:\n",
        "            trackType = f'#audio:group=1'\n",
        "        elif trackType == 3:\n",
        "            trackType = f':group=2'\n",
        "\n",
        "        trackTitle = input(f'    |\\n    |--Set track properties\\n    |\\n    |--Track Title: ')\n",
        "        trackLang = input(f'    |--Track Language: ')\n",
        "\n",
        "        if not trackLang:\n",
        "            inputParams = inputParams + f'-add \"{inputFile}{trackType}:name={trackTitle}\" '\n",
        "        else:\n",
        "            inputParams = inputParams + f'-add \"{inputFile}{trackType}:name={trackTitle}:lang={trackLang}\" '\n",
        "\n",
        "        inputLine.append(inputParams)\n",
        "        inputParams = \"\"\n",
        "\n",
        "    commandLine = commandLine + ''.join(inputLine)\n",
        "    outputFilename = input(f'\\noutputFilename: ')\n",
        "\n",
        "    if not outputFilename:\n",
        "        outputFilename = f'MP4Box_output'\n",
        "\n",
        "    outputPath = os.path.join(outputFolder, outputFilename)\n",
        "    commandLine = commandLine + f'-new \"{outputPath}.{outputFormat}\"'\n",
        "\n",
        "    command = f'tool=\"\"'\n",
        "\n",
        "    tags = input(f'\\nDo you want to add tags? [y/n] ')\n",
        "\n",
        "    if tags.lower() == 'y':\n",
        "        title = input(f'\\nMP4Box : MP4/M4A Tags\\n|\\n|--Title: ')\n",
        "        album = input(f'|--Album: ')\n",
        "        artist = input(f'|--Artist: ')\n",
        "        album_artist = input(f'|--Album Artist: ')\n",
        "        genre = input(f'|--Genre: ')\n",
        "        composer = input(f'|--Composer: ')\n",
        "        recorded_date = input(f'|--Recorded date: ')\n",
        "        track = input(f'|--Track no.: ')\n",
        "        track_total = input(f'|--Track Total: ')\n",
        "        disc = input(f'|--Disc no.: ')\n",
        "        disc_total = input(f'|--Disc Total: ')\n",
        "        group = input(f'|--Group: ')\n",
        "        comment = input(f'|--Comment: ')\n",
        "        tempo = input(f'|--Tempo: ')\n",
        "        compilation = input(f'|--Compilation: [y/n] ')\n",
        "        cover = input(f'|--Cover: ')\n",
        "\n",
        "        if artist: command += f':artist={artist}'\n",
        "        if album_artist: command += f':album_artist={album_artist}'\n",
        "        if album: command += f':album={album}'\n",
        "        if title: command += f':title={title}'\n",
        "        if genre: command += f':genre={genre}'\n",
        "        if composer: command += f':writer={composer}'\n",
        "        if recorded_date: command += f':created={recorded_date}'\n",
        "        if not disc_total:\n",
        "            if disc: command += f':disk={disc}/0'\n",
        "        else: command += f':disk={disc}/{disc_total}'\n",
        "        if not track_total:\n",
        "            if track: command += f':tracknum={track}/0'\n",
        "        else: command += f':tracknum={track}/{track_total}'\n",
        "        if comment: command += f':comment={comment}'\n",
        "        if group: command += f':group={group}'\n",
        "        if tempo: command += f':tempo={tempo}'\n",
        "        if compilation == 'y': command += f':compilation=yes'\n",
        "        elif compilation == 'n': command += f':compilation=no'\n",
        "        if cover: command += f':cover={cover}'\n",
        "        print(' ')\n",
        "    else:\n",
        "        print(f'No Tags Added!\\n')\n",
        "\n",
        "    addTags = f'-itags \"{command}\" '\n",
        "    !MP4Box {addTags} {commandLine}\n",
        "else:\n",
        "    !MP4Box -languages"
      ],
      "metadata": {
        "cellView": "form",
        "id": "7loG8MBXMO0H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Tag MP4 / M4A Files__"
      ],
      "metadata": {
        "id": "SGSsYJyD1CJz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Enter **MP4 or M4A** file path in **`inputFile`**.\n",
        "* `updateFile`: Update the exsisting file with tags.\n",
        "* Recommended to use [**Mutagen MP4/M4A tagger**](#scrollTo=MP4_M4A) for advanced use."
      ],
      "metadata": {
        "id": "T64whYcG1Fr3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "updateFile = True #@param {type:\"boolean\"}\n",
        "\n",
        "title = input(f'\\nMP4Box : MP4/M4A Tags\\n|\\n|--Title: ')\n",
        "album = input(f'|--Album: ')\n",
        "artist = input(f'|--Artist: ')\n",
        "album_artist = input(f'|--Album Artist: ')\n",
        "genre = input(f'|--Genre: ')\n",
        "composer = input(f'|--Composer: ')\n",
        "recorded_date = input(f'|--Recorded date: ')\n",
        "track = input(f'|--Track no.: ')\n",
        "track_total = input(f'|--Track Total: ')\n",
        "disc = input(f'|--Disc no.: ')\n",
        "disc_total = input(f'|--Disc Total: ')\n",
        "group = input(f'|--Group: ')\n",
        "comment = input(f'|--Comment: ')\n",
        "tempo = input(f'|--Tempo: ')\n",
        "compilation = input(f'|--Compilation: [y/n] ')\n",
        "cover = input(f'|--Cover: ')\n",
        "\n",
        "command = f'tool=\"\"'\n",
        "\n",
        "if artist: command += f':artist={artist}'\n",
        "if album_artist: command += f':album_artist={album_artist}'\n",
        "if album: command += f':album={album}'\n",
        "if title: command += f':name={title}'\n",
        "if genre: command += f':genre={genre}'\n",
        "if composer: command += f':writer={composer}'\n",
        "if recorded_date: command += f':created={recorded_date}'\n",
        "if not disc_total:\n",
        "    if disc: command += f':disk={disc}/0'\n",
        "else: command += f':disk={disc}/{disc_total}'\n",
        "if not track_total:\n",
        "    if track: command += f':tracknum={track}/0'\n",
        "else: command += f':tracknum={track}/{track_total}'\n",
        "if comment: command += f':comment={comment}'\n",
        "if group: command += f':group={group}'\n",
        "if tempo: command += f':tempo={tempo}'\n",
        "if compilation == 'y': command += f':compilation=yes'\n",
        "elif compilation == 'n': command += f':compilation=no'\n",
        "if cover: command += f':cover={cover}'\n",
        "\n",
        "if updateFile:\n",
        "  print(\" \")\n",
        "  !MP4Box -itags {command} \"{inputFile}\"\n",
        "else:\n",
        "  outputPath = input(f'\\noutputPath: ')\n",
        "  print(\" \")\n",
        "  !MP4Box -itags {command} -add \"{inputFile}\" -new \"{outputPath}\""
      ],
      "metadata": {
        "cellView": "form",
        "id": "DjtDOvDh1LZW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __MKVToolNix__"
      ],
      "metadata": {
        "id": "XU0jaWNWE1wh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Run below cell to **install** MKVToolNix.\n",
        "* You can use any version, to do that enter the version in `Version`.\n",
        "* If you want to install `version 70.0.0`, just type `70` in `Version`."
      ],
      "metadata": {
        "id": "UkinR6TWE-cH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://github.com/dropcreations/Essential-Google-Colab-Notebook/blob/main/cell_logos/MKVToolNix-Logo.png?raw=true' height=\"50\" alt=\"mkvtoolnix-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install MKVToolNix</b></h3></center><br>\n",
        "\n",
        "import json\n",
        "import requests\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Version = \"latest-release\" #@param [\"latest-release\"] {allow-input: true}\n",
        "\n",
        "response = requests.get(\"https://mkvtoolnix.download/releases.json\")\n",
        "release_info = json.loads(response.text)\n",
        "latest_version = release_info[\"mkvtoolnix-releases\"][\"latest-source\"].get(\"version\")\n",
        "\n",
        "releases = []\n",
        "\n",
        "for i in range(len(release_info[\"mkvtoolnix-releases\"].get(\"releases\"))):\n",
        "    ver = release_info[\"mkvtoolnix-releases\"][\"releases\"][i].get(\"version\")\n",
        "    releases.append(ver)\n",
        "\n",
        "if Version == \"latest-release\":\n",
        "    download_link = f'https://mkvtoolnix.download/appimage/MKVToolNix_GUI-{latest_version}-x86_64.AppImage'\n",
        "else:\n",
        "    for match in sorted(releases):\n",
        "        if Version in match:\n",
        "            Version = match\n",
        "    download_link = f'https://mkvtoolnix.download/appimage/MKVToolNix_GUI-{Version}-x86_64.AppImage'\n",
        "\n",
        "!rm -f '/usr/local/bin/mkvpropedit'\n",
        "!rm -f '/usr/local/bin/mkvmerge'\n",
        "!rm -f '/usr/local/bin/mkvextract'\n",
        "!rm -f '/usr/local/bin/mkvinfo'\n",
        "\n",
        "!sudo curl -L {download_link} -o /usr/local/bin/MKVToolNix_GUI.AppImage\n",
        "!sudo chmod u+rx /usr/local/bin/MKVToolNix_GUI.AppImage\n",
        "!sudo ln -s /usr/local/bin/MKVToolNix_GUI.AppImage /usr/local/bin/mkvpropedit\n",
        "!sudo chmod a+rx /usr/local/bin/mkvpropedit\n",
        "!sudo ln -s /usr/local/bin/MKVToolNix_GUI.AppImage /usr/local/bin/mkvmerge\n",
        "!sudo chmod a+rx /usr/local/bin/mkvmerge\n",
        "!sudo ln -s /usr/local/bin/MKVToolNix_GUI.AppImage /usr/local/bin/mkvextract\n",
        "!sudo chmod a+rx /usr/local/bin/mkvextract\n",
        "!sudo ln -s /usr/local/bin/MKVToolNix_GUI.AppImage /usr/local/bin/mkvinfo\n",
        "!sudo chmod a+rx /usr/local/bin/mkvinfo\n",
        "\n",
        "clear_output()\n",
        "!mkvmerge --version"
      ],
      "metadata": {
        "id": "gVhL2N16FD62",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __mkvmerge__"
      ],
      "metadata": {
        "id": "Wg4p2UnHFRxN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* You can __add__ tracks while running the cell.\n",
        "* Don't use `#` and `\"` in `mkvTitle`.\n",
        "* Add XML file path for `globalTags`, `segmentInfo`.\n",
        "* Choose a `splitMode` and add `splitArgument` __according__ to the `splitMode`.\n",
        "* Chapters are accpeted __both__ `XML` and `OGM_txt` files.\n",
        "* When adding a language use __laguage codes__.\n",
        "* If you don't want to fill a field, leave it blank.\n",
        "* If you don't know what is the relevant `mime-type`, also leave it blank in `mimeType`.\n",
        "* When adding track `default`, `forced` flags, If you leave it blank, it's value will be __\"No\"__.\n",
        "* For all `[y/n]` inputs __\"y\"__ for __\"yes\"__ and __\"n\"__ for __\"no\"__.\n",
        "* `webmCompliantFile`: Create a WebM compliant file instead of mkv file output.\n",
        "* While adding tracks if you have done adding, leave `inputFile` as blank to continue.\n",
        "* When saving options are asked, enter folder path that you want to save your output file in `Enter folder path: ` and enter a file name to add to your output file in `Enter a name to save: `.\n",
        "* If you leave both `Enter folder path: ` and `Enter a name to save: `, output folder will be `/content/` and your file will be renamed as the string that you gave in `mkvTitle`. If you haven't added `mkvTitle`, then your file will be renamed as same as the first inputed file's name. If a file exsists with the name generated for file, this will add `_new` to the end."
      ],
      "metadata": {
        "id": "aMrg46NhFc71"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <h3><b>General</b></h3>\n",
        "mkvTitle = \"\" #@param {type:\"string\"}\n",
        "globalTags = \"\" #@param {type:\"string\"}\n",
        "segmentInfo = \"\" #@param {type:\"string\"}\n",
        "#@markdown <h3><b>Split</b></h3>\n",
        "splitMode = \"Do not split\" #@param [\"Do not split\", \"After output size\", \"After output duration\", \"After specific timestamps\", \"by parts based on timestamps\", \"by parts based on frame/field numbers\", \"After frame/field numbers\", \"Before chapters\"]\n",
        "splitArgument = \"\" #@param {type:\"string\"}\n",
        "maxSplits = 0 #@param {type:\"integer\"}\n",
        "linkFiles = False #@param {type:\"boolean\"}\n",
        "#@markdown <h3><b>Chapters</b></h3>\n",
        "chaptersFile = \"\" #@param {type:\"string\"}\n",
        "chaptersLang = \"\" #@param {type:\"string\"}\n",
        "#@markdown <h3><b>Attachments</b></h3>\n",
        "attachment = \"\" #@param {type:\"string\"}\n",
        "name = \"\" #@param {type:\"string\"}\n",
        "mimeType = \"\" #@param {type:\"string\"}\n",
        "description = \"\" #@param {type:\"string\"}\n",
        "#@markdown <h3><b>Miscellaneous</b></h3>\n",
        "webmCompliantFile = False #@param {type:\"boolean\"}\n",
        "disableTrackStatisticsTags = False #@param {type:\"boolean\"}\n",
        "\n",
        "import os\n",
        "import json\n",
        "import subprocess\n",
        "from prettytable import PrettyTable\n",
        "\n",
        "class mkvmerge(object):\n",
        "    def __init__(self):\n",
        "        self.__input_files = []\n",
        "        self.__input_cmds = []\n",
        "        self.__input_codes = \"\"\n",
        "\n",
        "    def __get_json(self):\n",
        "        json_cmd = [\n",
        "            \"mkvmerge\",\n",
        "            \"--identify\",\n",
        "            \"--identification-format\",\n",
        "            \"json\",\n",
        "            os.path.abspath(self.input_file)\n",
        "        ]\n",
        "        json_data = subprocess.check_output(json_cmd, stderr=subprocess.DEVNULL)\n",
        "        json_data = json.loads(json_data)\n",
        "\n",
        "        return json_data\n",
        "\n",
        "    def __get_info(self, i):\n",
        "        json_data = self.__get_json()\n",
        "        self.id = json_data[\"tracks\"][i].get(\"id\")\n",
        "        self.language = json_data[\"tracks\"][i][\"properties\"].get(\"language\")\n",
        "        self.codec = json_data[\"tracks\"][i].get(\"codec\")\n",
        "        self.track_type = json_data[\"tracks\"][i].get(\"type\")\n",
        "\n",
        "    def __view_tracks(self, length):\n",
        "        table = PrettyTable(['id ', 'type', 'language', 'codec'])\n",
        "\n",
        "        for i in range(length):\n",
        "            self.__get_info(i)\n",
        "            table.add_row([self.id, self.track_type, self.language, self.codec])\n",
        "\n",
        "        table.align['id '] = \"c\"\n",
        "        table.align['type'] = \"l\"\n",
        "        table.align['language'] = \"c\"\n",
        "        table.align['codec'] = \"l\"\n",
        "\n",
        "        print(table)\n",
        "\n",
        "    def get_start(self):\n",
        "        while True:\n",
        "            self.input_file = input(\"\\ninputFile: \")\n",
        "            if self.input_file == \"\":\n",
        "                break\n",
        "            self.__input_files.append(self.input_file)\n",
        "            json_data = self.__get_json()\n",
        "\n",
        "            track_count = len(json_data.get(\"tracks\"))\n",
        "            track_id = 0\n",
        "\n",
        "            if track_count > 1:\n",
        "                print()\n",
        "                self.__view_tracks(track_count)\n",
        "                track_id = int(input(\"\\ntrack ID: \"))\n",
        "\n",
        "                if json_data[\"tracks\"][track_id].get(\"type\") == \"video\":\n",
        "                    display_dimensions = json_data[\"tracks\"][track_id][\"properties\"].get('display_dimensions')\n",
        "                    self.__input_codes += f'--no-audio --no-subtitles --no-attachments --no-track-tags --no-global-tags --no-chapters --display-dimensions {track_id}:{display_dimensions} '\n",
        "\n",
        "                elif json_data[\"tracks\"][track_id].get(\"type\") == \"audio\":\n",
        "                    self.__input_codes += f'--no-video --no-subtitles --no-attachments --no-track-tags --no-global-tags --no-chapters '\n",
        "\n",
        "                elif json_data[\"tracks\"][track_id].get(\"type\") == \"subtitles\":\n",
        "                    self.__input_codes += f'--no-video --no-audio --no-attachments --no-track-tags --no-global-tags --no-chapters '\n",
        "\n",
        "            track_title = input(\"|\\n|--trackTitle: \")\n",
        "            if track_title: self.__input_codes += f'--track-name {track_id}:\"{track_title}\" '\n",
        "\n",
        "            track_language = input(\"|--trackLanguage: \")\n",
        "            if track_language: self.__input_codes += f'--language {track_id}:{track_language} '\n",
        "\n",
        "            track_default = input(\"|--Set track as default? [y/n] \")\n",
        "            if track_default.lower() == \"n\" or track_default == \"\": self.__input_codes += f'--default-track-flag {track_id}:no '\n",
        "            elif track_default.lower() == \"y\": self.__input_codes += f'--default-track-flag {track_id}:yes '\n",
        "\n",
        "            track_forced = input(\"|--Set track as forced? [y/n] \")\n",
        "            if track_forced.lower() == \"n\" or track_forced == \"\": self.__input_codes += f'--forced-display-flag {track_id}:no '\n",
        "            elif track_forced.lower() == \"y\": self.__input_codes += f'--forced-display-flag {track_id}:yes '\n",
        "\n",
        "            self.__input_codes += f'\"{self.input_file}\" '\n",
        "            self.__input_cmds.append(self.__input_codes)\n",
        "            self.__input_codes = \"\"\n",
        "\n",
        "        if globalTags != \"\": self.__input_codes += f'--global-tags \"{globalTags}\" '\n",
        "        if segmentInfo != \"\": self.__input_codes += f'--segmentinfo \"{segmentInfo}\" '\n",
        "\n",
        "        if splitMode == \"After output size\": self.__input_codes += f'--split size:{splitArgument} '\n",
        "        elif splitMode == \"After output duration\": self.__input_codes += f'--split duration:{splitArgument} '\n",
        "        elif splitMode == \"After specific timestamps\": self.__input_codes += f'--split timestamps:{splitArgument} '\n",
        "        elif splitMode == \"by parts based on timestamps\": self.__input_codes += f'--split parts:{splitArgument} '\n",
        "        elif splitMode == \"by parts based on frame/field numbers\": self.__input_codes += f'--split parts-frames:{splitArgument} '\n",
        "        elif splitMode == \"After frame/field numbers\": self.__input_codes += f'--split frames:{splitArgument} '\n",
        "        elif splitMode == \"Before chapters\": self.__input_codes += f'--split chapters:{splitArgument} '\n",
        "\n",
        "        if maxSplits > 1: self.__input_codes += f'--split-max-files {maxSplits} '\n",
        "        if linkFiles: self.__input_codes += f'--link '\n",
        "\n",
        "        if chaptersLang != \"\": self.__input_codes += f'--chapter-language {chaptersLang} '\n",
        "        if chaptersFile != \"\": self.__input_codes += f'--chapters \"{chaptersFile}\" '\n",
        "\n",
        "        if attachment != \"\":\n",
        "            if name != \"\":\n",
        "                attachment_ext = os.path.splitext(attachment)[1]\n",
        "                name_ext = os.path.splitext(name)[1]\n",
        "                if name_ext == attachment_ext: attachment_ext = \"\"\n",
        "                self.__input_codes += f'--attachment-name \"{name}{attachment_ext}\" '\n",
        "            if mimeType != \"\": self.__input_codes += f'--attachment-mime-type {mimeType} '\n",
        "            if description != \"\": self.__input_codes += f'--attachment-description \"{description}\" '\n",
        "            self.__input_codes += f'--attach-file \"{attachment}\" '\n",
        "\n",
        "        print(\"\\nSave output file to...\\n|\")\n",
        "        output_dir = input(\"|--Enter folder path: \")\n",
        "        output_name = input(\"|--Enter a name to save: \")\n",
        "        print()\n",
        "\n",
        "        if not output_dir: output_dir = \"/content/\"\n",
        "        if not output_name:\n",
        "            if not mkvTitle:\n",
        "                if webmCompliantFile: output_name = os.path.splitext(os.path.basename(self.__input_files[0]))[0] + '.webm'\n",
        "                else: output_name = os.path.splitext(os.path.basename(self.__input_files[0]))[0] + '.mkv'\n",
        "            else:\n",
        "                if webmCompliantFile: output_name = mkvTitle + '.webm'\n",
        "                else: output_name = mkvTitle + '.mkv'\n",
        "        else:\n",
        "            if not (output_name.endswith('.webm') or output_name.endswith('.mkv')):\n",
        "                if webmCompliantFile: output_name += '.webm'\n",
        "                else: output_name += '.mkv'\n",
        "\n",
        "        output_dir = os.path.join(os.path.abspath(output_dir), output_name)\n",
        "        if os.path.exists(output_dir):\n",
        "            output_dir = f\"{os.path.splitext(output_dir)[0]}_new{os.path.splitext(output_dir)[1]}\"\n",
        "        command_line = f'--output \"{output_dir}\" '\n",
        "\n",
        "        if webmCompliantFile: command_line += f'--webm '\n",
        "        if disableTrackStatisticsTags: command_line += f'--disable-track-statistics-tags '\n",
        "\n",
        "        command_line += ''.join(self.__input_cmds) + self.__input_codes\n",
        "        if mkvTitle != \"\": command_line += f'--title \"{mkvTitle}\"'\n",
        "\n",
        "        return command_line\n",
        "\n",
        "mkv_merge = mkvmerge()\n",
        "!mkvmerge {mkv_merge.get_start()}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "wfcL4VNRZqD6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __mkvextract__"
      ],
      "metadata": {
        "id": "ElG5vp-SQNqm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* You can extract __all tracks, attachments, chapters, tags, cues, cue sheet, timecodes__ from `MKV` and `WebM` files.\n",
        "* Also you can extract a __single track__ by selecting `extractMode: Single Track` option.\n",
        "* While extracting chapters, enter `chapters extract type?` as `xml` or `ogm` when asked for extract in that format\n",
        "* `inputFile` can be a file or folder that contains `MKV` and `WebM` files. Don't need to contain only MKV and WebM files."
      ],
      "metadata": {
        "id": "2PTf-br2-_vB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputFile = \"\" #@param {type:\"string\"}\n",
        "extractMode = \"Tracks\" #@param [\"Tracks\", \"Chapters\", \"Attachments\", \"Tags\", \"Cue Sheet\", \"Timecodes\", \"Cues\", \"Single Track\"]\n",
        "\n",
        "import os\n",
        "import json\n",
        "import subprocess\n",
        "from prettytable import PrettyTable\n",
        "\n",
        "class mkvextract(object):\n",
        "    def __init__(self):\n",
        "        self.input_file = os.path.abspath(inputFile)\n",
        "        if not os.path.isfile(self.input_file): self.input_file = self.__process_dir()\n",
        "        if not isinstance(self.input_file, list): self.input_file = [self.input_file]\n",
        "\n",
        "    def __process_dir(self):\n",
        "        content = os.listdir(self.input_file)\n",
        "        content = [os.path.join(self.input_file, file) for file in content if os.path.splitext(file)[-1] in [\".mkv\", \".webm\"]]\n",
        "        return content\n",
        "\n",
        "    def __get_json(self, input_file):\n",
        "        json_cmd = [\n",
        "            \"mkvmerge\",\n",
        "            \"--identify\",\n",
        "            \"--identification-format\",\n",
        "            \"json\",\n",
        "            input_file\n",
        "        ]\n",
        "        json_data = subprocess.check_output(json_cmd, stderr=subprocess.DEVNULL)\n",
        "        json_data = json.loads(json_data)\n",
        "        return json_data\n",
        "\n",
        "    def __get_info(self, json_data, i:int):\n",
        "        self.id = json_data[\"tracks\"][i].get(\"id\")\n",
        "        self.language = json_data[\"tracks\"][i][\"properties\"].get(\"language\")\n",
        "        self.language_ietf = json_data[\"tracks\"][i][\"properties\"].get(\"language_ieft\")\n",
        "        self.codec = json_data[\"tracks\"][i].get(\"codec\")\n",
        "        self.track_type = json_data[\"tracks\"][i].get(\"type\")\n",
        "        self.track_name = json_data[\"tracks\"][i][\"properties\"].get('track_name')\n",
        "        self.codec_id = json_data[\"tracks\"][i][\"properties\"].get('codec_id')\n",
        "\n",
        "    def __view_tracks(self, length, input_file):\n",
        "        table = PrettyTable(['id ', 'type', 'language', 'codec', 'name'])\n",
        "\n",
        "        for i in range(length):\n",
        "            json_data = self.__get_json(input_file)\n",
        "            self.__get_info(json_data, i)\n",
        "            table.add_row([self.id, self.track_type, self.language, self.codec, self.track_name])\n",
        "\n",
        "        table.align['id '] = \"c\"\n",
        "        table.align['type'] = \"l\"\n",
        "        table.align['language'] = \"c\"\n",
        "        table.align['codec'] = \"l\"\n",
        "        table.align['name'] = \"l\"\n",
        "\n",
        "        print(table)\n",
        "\n",
        "    def __make_extract_dir(self, input_file):\n",
        "        input_dir = os.path.dirname(input_file)\n",
        "        input_name = os.path.splitext(os.path.basename(input_file))[0]\n",
        "        os.makedirs(os.path.join(input_dir, input_name), exist_ok=True)\n",
        "        return os.path.join(input_dir, input_name)\n",
        "\n",
        "    def __process_file(self, i:int, input_file):\n",
        "        json_data = self.__get_json(input_file)\n",
        "        if self.track_type == \"video\":\n",
        "            pixel_dimensions = json_data[\"tracks\"][i][\"properties\"].get('pixel_dimensions')\n",
        "            self.extract_name = f'Track_{self.id}_[{self.track_type}]_[{pixel_dimensions}]_[{self.language}]'\n",
        "        elif self.track_type == \"audio\":\n",
        "            audio_channels = json_data[\"tracks\"][i][\"properties\"].get('audio_channels')\n",
        "            audio_sampling_frequency = json_data[\"tracks\"][i][\"properties\"].get('audio_sampling_frequency')\n",
        "            self.extract_name = f'Track_{self.id}_[{self.track_type}]_[{audio_channels}CH]_[{audio_sampling_frequency / 1000}kHz]_[{self.language}]'\n",
        "        elif self.track_type == \"subtitles\":\n",
        "            self.extract_name = f'Track_{self.id}_[{self.track_type}]_[{self.language}]'\n",
        "\n",
        "        if \"AVC\" in self.codec_id:\n",
        "            self.extract_name += \".h264\"\n",
        "        elif \"HEVC\" in self.codec_id:\n",
        "            self.extract_name += \".h265\"\n",
        "        elif \"V_VP8\" in self.codec_id or \"V_VP9\" in self.codec_id:\n",
        "            self.extract_name += \".ivf\"\n",
        "        elif \"V_AV1\" in self.codec_id:\n",
        "            self.extract_name += \".ivf\"\n",
        "        elif \"V_MPEG1\" in self.codec_id or \"V_MPEG2\" in self.codec_id:\n",
        "            self.extract_name += \".mpg\"\n",
        "        elif \"V_REAL\" in self.codec_id:\n",
        "            self.extract_name += \".rm\"\n",
        "        elif \"V_THEORA\" in self.codec_id:\n",
        "            self.extract_name += \".ogg\"\n",
        "        elif \"V_MS/VFW/FOURCC\" in self.codec_id:\n",
        "            self.extract_name += \".avi\"\n",
        "        elif \"AAC\" in self.codec_id:\n",
        "            self.extract_name += \".aac\"\n",
        "        elif \"A_AC3\" in self.codec_id:\n",
        "            self.extract_name += \".ac3\"\n",
        "        elif \"A_EAC3\" in self.codec_id:\n",
        "            self.extract_name += \".eac3\"\n",
        "        elif \"ALAC\" in self.codec_id:\n",
        "            self.extract_name += \".caf\"\n",
        "        elif \"DTS\" in self.codec_id:\n",
        "            self.extract_name += \".dts\"\n",
        "        elif \"FLAC\" in self.codec_id:\n",
        "            self.extract_name += \".flac\"\n",
        "        elif \"MPEG/L2\" in self.codec_id:\n",
        "            self.extract_name += \".mp2\"\n",
        "        elif \"MPEG/L3\" in self.codec_id:\n",
        "            self.extract_name += \".mp3\"\n",
        "        elif \"OPUS\" in self.codec_id:\n",
        "            self.extract_name += \".ogg\"\n",
        "        elif \"PCM\" in self.codec_id:\n",
        "            self.extract_name += \".wav\"\n",
        "        elif \"REAL\" in self.codec_id:\n",
        "            self.extract_name += \".ra\"\n",
        "        elif \"TRUEHD\" in self.codec_id:\n",
        "            self.extract_name += \".thd\"\n",
        "        elif \"MLP\" in self.codec_id:\n",
        "            self.extract_name += \".mlp\"\n",
        "        elif \"TTA1\" in self.codec_id:\n",
        "            self.extract_name += \".tta\"\n",
        "        elif \"VORBIS\" in self.codec_id:\n",
        "            self.extract_name += \".ogg\"\n",
        "        elif \"WAVPACK4\" in self.codec_id:\n",
        "            self.extract_name += \".wv\"\n",
        "        elif \"PGS\" in self.codec_id:\n",
        "            self.extract_name += \".sup\"\n",
        "        elif \"ASS\" in self.codec_id:\n",
        "            self.extract_name += \".ass\"\n",
        "        elif \"SSA\" in self.codec_id:\n",
        "            self.extract_name += \".ssa\"\n",
        "        elif \"UTF8\" in self.codec_id or \"ASCII\" in self.codec_id:\n",
        "            self.extract_name += \".srt\"\n",
        "        elif \"VOBSUB\" in self.codec_id:\n",
        "            self.extract_name += \".sub\"\n",
        "        elif \"S_KATE\" in self.codec_id:\n",
        "            self.extract_name += \".ogg\"\n",
        "        elif \"USF\" in self.codec_id:\n",
        "            self.extract_name += \".usf\"\n",
        "        elif \"WEBVTT\" in self.codec_id:\n",
        "            self.extract_name += \".vtt\"\n",
        "\n",
        "    def __extract_tracks(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        extract_codes = []\n",
        "\n",
        "        for i in range(len(json_data[\"tracks\"])):\n",
        "            self.__get_info(json_data, int(i))\n",
        "            self.__process_file(int(i), input_file)\n",
        "            extract_codes.append(f'{self.id}:\"{os.path.join(extract_dir, self.extract_name)}\"')\n",
        "\n",
        "        cmd = f'mkvextract \"{input_file}\" tracks {\" \".join(extract_codes)}'\n",
        "        print(\"Extracting...\")\n",
        "        !{cmd}\n",
        "\n",
        "    def __extract_a_single_track(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        self.__view_tracks(len(json_data[\"tracks\"]), input_file)\n",
        "        i = input(\"\\ntrack ID: \")\n",
        "\n",
        "        self.__get_info(json_data, int(i))\n",
        "        self.__process_file(int(i), input_file)\n",
        "\n",
        "        cmd = f'mkvextract \"{input_file}\" tracks {self.id}:\"{os.path.join(extract_dir, self.extract_name)}\"'\n",
        "        print(\"\\nExtracting...\")\n",
        "        !{cmd}\n",
        "\n",
        "    def __extract_attachments(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        if len(json_data.get(\"attachments\")) > 0:\n",
        "            for attachment in json_data.get(\"attachments\"):\n",
        "                attachment_id = attachment.get(\"id\")\n",
        "                attachment_name = attachment.get(\"file_name\")\n",
        "                extractParam = (f'')\n",
        "                cmd = f'mkvextract \"{input_file}\" attachments {attachment_id}:\"{os.path.join(extract_dir, attachment_name)}\"'\n",
        "                !{cmd}\n",
        "        elif len(json_data.get(\"attachments\")) == 0:\n",
        "            print(\"No attachments are available.\")\n",
        "\n",
        "    def __extract_chapters(self, chapter_type, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        if len(json_data.get(\"chapters\")) > 0:\n",
        "            if chapter_type == \"xml\": cmd = f'mkvextract \"{input_file}\" chapters \"{os.path.join(extract_dir, \"Chapters.xml\")}\"'\n",
        "            elif chapter_type == \"ogm\": cmd = f'mkvextract \"{input_file}\" chapters --simple \"{os.path.join(extract_dir, \"Chapters.txt\")}\"'\n",
        "            !{cmd}\n",
        "            print(\"Extracted.\")\n",
        "        elif len(json_data.get(\"chapters\")) == 0:\n",
        "            print(\"No chapters are available.\")\n",
        "\n",
        "    def __extract_tags(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        if len(json_data.get(\"global_tags\")) or len(json_data.get(\"track_tags\")) > 0:\n",
        "            cmd = f'mkvextract \"{input_file}\" tags \"{os.path.join(extract_dir, \"Tags.xml\")}\"'\n",
        "            !{cmd}\n",
        "            print(\"Extracted.\")\n",
        "        elif (len(json_data.get(\"global_tags\")) == 0) and (len(json_data.get(\"track_tags\")) == 0):\n",
        "            print(\"No tags are available.\")\n",
        "\n",
        "    def __extract_timecodes(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        extract_codes = []\n",
        "\n",
        "        for i in range(len(json_data[\"tracks\"])):\n",
        "            self.__get_info(json_data, int(i))\n",
        "            extract_name = f'Track_{self.id}_[{self.track_type}]_tc.txt'\n",
        "            extract_codes.append(f'{self.id}:\"{os.path.join(extract_dir, extract_name)}\"')\n",
        "\n",
        "        cmd = f'mkvextract \"{input_file}\" timecodes_v2 {\" \".join(extract_codes)}'\n",
        "        print(\"Extracting...\")\n",
        "        !{cmd}\n",
        "\n",
        "    def __extract_cues(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        json_data = self.__get_json(input_file)\n",
        "\n",
        "        extract_codes = []\n",
        "\n",
        "        for i in range(len(json_data[\"tracks\"])):\n",
        "            self.__get_info(json_data, int(i))\n",
        "            extract_name = f'Track_{self.id}_[{self.track_type}]_cues.txt'\n",
        "            extract_codes.append(f'{self.id}:\"{os.path.join(extract_dir, extract_name)}\"')\n",
        "\n",
        "        cmd = f'mkvextract \"{input_file}\" cues {\" \".join(extract_codes)}'\n",
        "        print(\"Extracting...\")\n",
        "        !{cmd}\n",
        "\n",
        "    def __extract_cuesheet(self, input_file):\n",
        "        extract_dir = self.__make_extract_dir(input_file)\n",
        "        cmd = f'mkvextract \"{input_file}\" cuesheet \"{os.path.join(extract_dir, \"CueSheet.cue\")}\"'\n",
        "        !{cmd}\n",
        "        print(\"Extracted.\")\n",
        "\n",
        "    def get_start(self):\n",
        "        if extractMode == \"Tracks\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_tracks(file)\n",
        "        elif extractMode == \"Single Track\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_a_single_track(file)\n",
        "        elif extractMode == \"Chapters\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                chapter_type = input(\"chapters extract type? [xml/ogm] \")\n",
        "                if chapter_type.lower() == \"xml\" or chapter_type.lower() == \"ogm\":\n",
        "                        self.__extract_chapters(chapter_type.lower(), file)\n",
        "                else: print(\"Incorrect input.\")\n",
        "        elif extractMode == \"Attachments\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_attachments(file)\n",
        "        elif extractMode == \"Tags\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_tags(file)\n",
        "        elif extractMode == \"Timecodes\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_timecodes(file)\n",
        "        elif extractMode == \"Cues\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_cues(file)\n",
        "        elif extractMode == \"Cue Sheet\":\n",
        "            for file in self.input_file:\n",
        "                print()\n",
        "                self.__extract_cuesheet(file)\n",
        "\n",
        "mkv_extract = mkvextract()\n",
        "mkv_extract.get_start()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "caHVtMLr-u3Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __mkvpropedit__"
      ],
      "metadata": {
        "id": "nLRLw5WmQh21"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* You can edit __segment info, track info, chapters, attachments, tags__ in a mkv file.\n",
        "* If you want to __delete statistic tags__ from tracks select `deleteTrackStatisticsTags`"
      ],
      "metadata": {
        "id": "NFigasWtYur7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mkvFile = \"\" #@param {type:\"string\"}\n",
        "handleMode = \"None\" #@param [\"None\", \"Segment Info\", \"Tracks\", \"Chapters\", \"Attachments\", \"Tags\"]\n",
        "deleteTrackStatisticsTags = False #@param {type:\"boolean\"}\n",
        "\n",
        "import os\n",
        "import math\n",
        "import json\n",
        "import subprocess\n",
        "from prettytable import PrettyTable\n",
        "\n",
        "class mkvpropedit():\n",
        "    def __init__(self):\n",
        "        self.input_file = os.path.abspath(mkvFile)\n",
        "        self.__input_codes = \"\"\n",
        "\n",
        "    def __get_json(self):\n",
        "        json_cmd = [\n",
        "            \"mkvmerge\",\n",
        "            \"--identify\",\n",
        "            \"--identification-format\",\n",
        "            \"json\",\n",
        "            os.path.abspath(self.input_file)\n",
        "        ]\n",
        "        json_data = subprocess.check_output(json_cmd, stderr=subprocess.DEVNULL)\n",
        "        json_data = json.loads(json_data)\n",
        "        return json_data\n",
        "\n",
        "    def __get_track_info(self, json_data, i:int):\n",
        "        self.id = json_data[\"tracks\"][i].get(\"id\")\n",
        "        self.language = json_data[\"tracks\"][i][\"properties\"].get(\"language\")\n",
        "        self.language_ietf = json_data[\"tracks\"][i][\"properties\"].get(\"language_ieft\")\n",
        "        self.codec = json_data[\"tracks\"][i].get(\"codec\")\n",
        "        self.track_type = json_data[\"tracks\"][i].get(\"type\")\n",
        "        self.track_name = json_data[\"tracks\"][i][\"properties\"].get('track_name')\n",
        "        self.codec_id = json_data[\"tracks\"][i][\"properties\"].get('codec_id')\n",
        "\n",
        "    def __get_attachment_info(self, json_data, i:int):\n",
        "        self.attachment_id = json_data[\"attachments\"][i].get(\"id\")\n",
        "        self.attachment_name = json_data[\"attachments\"][i].get(\"file_name\")\n",
        "        self.attachment_type = json_data[\"attachments\"][i].get(\"content_type\")\n",
        "        self.attachment_description = json_data[\"attachments\"][i].get(\"description\")\n",
        "        if self.attachment_description == \"\": self.attachment_description = \"None\"\n",
        "        self.attachment_uid = json_data[\"attachments\"][i][\"properties\"].get(\"uid\")\n",
        "        self.attachment_size = self.__convert_size(json_data[\"attachments\"][i].get(\"size\"))\n",
        "\n",
        "    def __convert_size(self, size_bytes):\n",
        "        if size_bytes == 0:\n",
        "            return \"0B\"\n",
        "        size_name = (\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\")\n",
        "        i = int(math.floor(math.log(size_bytes, 1024)))\n",
        "        p = math.pow(1024, i)\n",
        "        s = round(size_bytes / p, 2)\n",
        "        return f\"{s} {size_name[i]}\"\n",
        "\n",
        "    def __view_tracks(self, json_data, length):\n",
        "        table = PrettyTable(['id ', 'type', 'language', 'codec', 'name'])\n",
        "\n",
        "        for i in range(length):\n",
        "            self.__get_track_info(json_data, i)\n",
        "            table.add_row([self.id, self.track_type, self.language, self.codec, self.track_name])\n",
        "\n",
        "        table.align['id '] = \"c\"\n",
        "        table.align['type'] = \"l\"\n",
        "        table.align['language'] = \"c\"\n",
        "        table.align['codec'] = \"l\"\n",
        "        table.align['name'] = \"l\"\n",
        "        print(table)\n",
        "\n",
        "    def __view_attachments(self, json_data, length):\n",
        "        table = PrettyTable(['id ', 'name', 'mime-type', 'size', 'uid', 'description'])\n",
        "\n",
        "        for i in range(length):\n",
        "            self.__get_attachment_info(json_data, i)\n",
        "            table.add_row([self.attachment_id, self.attachment_name, self.attachment_type, self.attachment_size, self.attachment_uid, self.attachment_description])\n",
        "\n",
        "        table.align['id '] = \"c\"\n",
        "        table.align['name'] = \"l\"\n",
        "        table.align['mime-type'] = \"l\"\n",
        "        table.align['size'] = \"l\"\n",
        "        table.align['uid'] = \"l\"\n",
        "        table.align['description'] = \"l\"\n",
        "        print(table)\n",
        "\n",
        "    def __edit_tracks(self):\n",
        "        json_data = self.__get_json()\n",
        "        self.__view_tracks(json_data, len(json_data.get(\"tracks\")))\n",
        "        track_id = int(input('\\ntrack ID: '))\n",
        "        mkvpropedit_id = track_id + 1\n",
        "        property_type = input(\"\\nproperty type to edit?\\n\\n1: Track Title\\n2: Track Language\\n3: Track Default\\n4: Track Forced\\n\\n[1/2/3/4] \")\n",
        "        if property_type in [\"1\", \"2\", \"3\", \"4\"]:\n",
        "            if property_type == \"1\":\n",
        "                edit_type = input(\"\\nHow to edit?\\n\\n1: Add\\n2: Change\\n3: Delete\\n\\n[1/2/3] \")\n",
        "                if edit_type in [\"1\", \"2\"]:\n",
        "                    track_title = input(\"\\nTitle: \")\n",
        "                    if edit_type == \"1\": self.__input_codes += f'--add name=\"{track_title}\"'\n",
        "                    elif edit_type == \"2\": self.__input_codes += f'--set name=\"{track_title}\"'\n",
        "                elif edit_type == \"3\": self.__input_codes += '--delete name'\n",
        "                else: return \"Incorrect input\"\n",
        "            elif property_type == \"2\":\n",
        "                edit_type = input(\"\\nHow to edit?\\n\\n1: Add\\n2: Change\\n3: Delete\\n\\n[1/2/3] \")\n",
        "                if edit_type in [\"1\", \"2\"]:\n",
        "                    track_lang = input(\"\\nLanguage: \")\n",
        "                    if edit_type == \"1\": self.__input_codes += f'--add language={track_lang}'\n",
        "                    elif edit_type == \"2\": self.__input_codes += f'--set language={track_lang}'\n",
        "                elif edit_type == \"3\": self.__input_codes += '--delete language'\n",
        "                else: return \"Incorrect input\"\n",
        "            elif property_type == \"3\":\n",
        "                track_default = input(f'\\nSet this track as default?\\n\\n0: No\\n1: Yes\\n\\n[0/1] ')\n",
        "                if track_default in [\"0\", \"1\"]: self.__input_codes += f'--set flag-default={track_default}'\n",
        "                else: return \"Incorrect input\"\n",
        "            elif property_type == \"4\":\n",
        "                track_forced = input(f'\\nSet this track as forced?\\n\\n0: No\\n1: Yes\\n\\n[0/1] ')\n",
        "                if track_forced in [\"0\", \"1\"]: self.__input_codes += f'--set flag-forced={track_forced}'\n",
        "                else: return \"Incorrect input\"\n",
        "            return f'\"{self.input_file}\" --edit track:{mkvpropedit_id} {self.__input_codes} '\n",
        "        else: return \"Incorrect input\"\n",
        "\n",
        "    def __edit_segment_info(self):\n",
        "        edit_type = input(\"Segment infomation : Title\\n\\n1: Add\\n2: Change\\n3: Delete\\n\\n[1/2/3] \")\n",
        "        if edit_type in [\"1\", \"2\"]:\n",
        "            mkv_title = input(\"\\nTitle: \")\n",
        "            if edit_type == \"1\": self.__input_codes += f'--add title=\"{mkv_title}\"'\n",
        "            elif edit_type == \"2\": self.__input_codes += f'--set title=\"{mkv_title}\"'\n",
        "        elif edit_type == \"3\": self.__input_codes += '--delete title'\n",
        "        else: return \"Incorrect input\"\n",
        "        return f'\"{self.input_file}\" --edit info {self.__input_codes} '\n",
        "\n",
        "    def __edit_chapters(self):\n",
        "        edit_type = input(\"Chapters\\n\\n1: Add\\n2: Remove\\n\\n[1/2] \")\n",
        "        if edit_type == \"1\":\n",
        "            file_path = input(\"\\nChapter file path: \")\n",
        "            self.__input_codes += f'--chapters \"{file_path}\"'\n",
        "        elif edit_type == \"2\": self.__input_codes += '--chapters \"\"'\n",
        "        else: return \"Incorrect input\"\n",
        "        return f'\"{self.input_file}\" --edit info {self.__input_codes} '\n",
        "\n",
        "    def __edit_attachments(self):\n",
        "        edit_type = input(f'Attachments\\n\\n1: Add\\n2: Replace\\n3: Update\\n4: Remove\\n5: List\\n\\n[1/2/3/4/5] ')\n",
        "        if edit_type == \"1\":\n",
        "            attachment_path = input(f'\\nattachment path: ')\n",
        "            attachment_ext = os.path.splitext(os.path.abspath(attachment_path))[-1]\n",
        "            attachment_name = input(f'\\nName: ')\n",
        "            attachment_mimetype = input(f'MIME-Type: ')\n",
        "            attachment_desc = input(f'Description: ')\n",
        "            attachment_uid = input(f'UID: ')\n",
        "\n",
        "            if attachment_name: self.__input_codes += f'--attachment-name \"{attachment_name}{attachment_ext}\" '\n",
        "            if attachment_mimetype: self.__input_codes += f'--attachment-mime-type \"{attachment_mimetype}\" '\n",
        "            if attachment_desc: self.__input_codes += f'--attachment-description \"{attachment_desc}\" '\n",
        "            if attachment_uid: self.__input_codes += f'--attachment-uid \"{attachment_uid}\" '\n",
        "\n",
        "            self.__input_codes += f'--add-attachment \"{attachment_path}\" '\n",
        "            return f'\"{self.input_file}\" {self.__input_codes} '\n",
        "        elif edit_type in [\"2\", \"3\", \"4\", \"5\"]:\n",
        "            print()\n",
        "            json_data = self.__get_json()\n",
        "            self.__view_attachments(json_data, len(json_data.get(\"attachments\")))\n",
        "\n",
        "            if edit_type in [\"2\", \"3\"]:\n",
        "                attachment_id = input(\"\\nattachment ID: \")\n",
        "                attachment_path = input(f'\\nattachment path: ')\n",
        "                attachment_ext = os.path.splitext(os.path.abspath(attachment_path))[-1]\n",
        "                attachment_name = input(f'\\nName: ')\n",
        "                attachment_mimetype = input(f'MIME-Type: ')\n",
        "                attachment_desc = input(f'Description: ')\n",
        "                attachment_uid = input(f'UID: ')\n",
        "\n",
        "                if attachment_name: self.__input_codes += f'--attachment-name \"{attachment_name}{attachment_ext}\" '\n",
        "                if attachment_mimetype: self.__input_codes += f'--attachment-mime-type \"{attachment_mimetype}\" '\n",
        "                if attachment_desc: self.__input_codes += f'--attachment-description \"{attachment_desc}\" '\n",
        "                if attachment_uid: self.__input_codes += f'--attachment-uid \"{attachment_uid}\" '\n",
        "\n",
        "                if edit_type == \"2\": self.__input_codes += f'--replace-attachment {attachment_id}:\"{attachment_path}\" '\n",
        "                elif edit_type == \"3\": self.__input_codes += f'--update-attachment {attachment_id} '\n",
        "\n",
        "                return f'\"{self.input_file}\" {self.__input_codes} '\n",
        "            elif edit_type == \"4\":\n",
        "                attachment_id = input(\"\\nattachment ID: \")\n",
        "                self.__input_codes += f'--delete-attachment {attachment_id} '\n",
        "                return f'\"{self.input_file}\" {self.__input_codes} '\n",
        "            return \"list\"\n",
        "        else: return \"Incorrect input\"\n",
        "\n",
        "    def __edit_tags(self):\n",
        "        edit_type = input('Tags\\n\\n1: All tags\\n2: Global tags\\n3: Track tags\\n\\n[1/2/3] ')\n",
        "        if edit_type in [\"1\", \"2\", \"3\"]:\n",
        "            if edit_type == \"1\":\n",
        "                tag_type = input('\\nAll Tags\\n\\n1: Add\\n2: Remove\\n\\n[1/2] ')\n",
        "                if tag_type in [\"1\", \"2\"]:\n",
        "                    if tag_type == \"1\":\n",
        "                        xml_path = input(f'\\nXML file path: ')\n",
        "                        self.__input_codes += f'--tags all:\"{xml_path}\" '\n",
        "                    elif tag_type == \"2\": self.__input_codes += '--tags all: '\n",
        "                    return f'\"{self.input_file}\" {self.__input_codes} '\n",
        "                else: return \"Incorrect input\"\n",
        "            elif edit_type == \"2\":\n",
        "                tag_type = input('\\nGlobal Tags\\n\\n1: Add\\n2: Remove\\n\\n[1/2] ')\n",
        "                if tag_type in [\"1\", \"2\"]:\n",
        "                    if tag_type == \"1\":\n",
        "                        xml_path = input(f'\\nXML file path: ')\n",
        "                        self.__input_codes += f'--tags global:\"{xml_path}\" '\n",
        "                    elif tag_type == \"2\": self.__input_codes += '--tags global: '\n",
        "                    return f'\"{self.input_file}\" {self.__input_codes} '\n",
        "                else: return \"Incorrect input\"\n",
        "            elif edit_type == \"3\":\n",
        "                print()\n",
        "                json_data = self.__get_json()\n",
        "                self.__view_tracks(json_data, len(json_data.get(\"tracks\")))\n",
        "                track_id = input(f'\\ntrack ID: ')\n",
        "                mkvpropedit_id = int(track_id) + 1\n",
        "                tag_type = input('\\nTrack Tags\\n\\n1: Add\\n2: Remove\\n\\n[1/2] ')\n",
        "                if tag_type in [\"1\", \"2\"]:\n",
        "                    if tag_type == '1':\n",
        "                        xml_path = input(f'\\nXML file path: ')\n",
        "                        self.__input_codes += f'--tags track:{mkvpropedit_id}:\"{xml_path}\" '\n",
        "                    elif tag_type == '2': self.__input_codes += f'--tags track:{mkvpropedit_id}: '\n",
        "                    return f'\"{self.input_file}\" {self.__input_codes} '\n",
        "                else: return \"Incorrect input\"\n",
        "        else: return \"Incorrect input\"\n",
        "\n",
        "    def get_start(self):\n",
        "        if deleteTrackStatisticsTags:\n",
        "            if handleMode == 'None': return f'{self.input_file} --delete-track-statistics-tags'\n",
        "            elif handleMode == 'Tracks': return f'{self.__edit_tracks()} --delete-track-statistics-tags'\n",
        "            elif handleMode == 'Segment Info': return f'{self.__edit_segment_info()} --delete-track-statistics-tags'\n",
        "            elif handleMode == 'Chapters': return f'{self.__edit_chapters()} --delete-track-statistics-tags'\n",
        "            elif handleMode == 'Attachments': return f'{self.__edit_attachments()} --delete-track-statistics-tags'\n",
        "            elif handleMode == 'Tags': return f'{self.__edit_tags()} --delete-track-statistics-tags'\n",
        "        else:\n",
        "            if handleMode == 'None': return f'{self.input_file}'\n",
        "            elif handleMode == 'Tracks': return self.__edit_tracks()\n",
        "            elif handleMode == 'Segment Info': return self.__edit_segment_info()\n",
        "            elif handleMode == 'Chapters': return self.__edit_chapters()\n",
        "            elif handleMode == 'Attachments': return self.__edit_attachments()\n",
        "            elif handleMode == 'Tags': return self.__edit_tags()\n",
        "\n",
        "mkv_propedit = mkvpropedit()\n",
        "cmd = mkv_propedit.get_start()\n",
        "print()\n",
        "if not \"Incorrect input\" in cmd and not \"list\" in cmd:\n",
        "    !mkvpropedit {cmd}\n",
        "elif \"Incorrect input\" in cmd:\n",
        "    print(\"Incorrect input\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Q6sN022hYlqV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Matroska/WebM Tags__"
      ],
      "metadata": {
        "id": "rQeTmPdh5ypS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Enter __mkv or webm file's path__ in `mkvFile`.\n",
        "* If you want to delete `Title`, leave it as blank.\n",
        "* You can add __tags__ using a __text document__, but the text document's content must be as formatted as below.<br>\n",
        "`Tag name: Tag value, Tag value`\n",
        "* This doesn't add tags as __multiple tags__, adds all values as a single tag.\n",
        "* Use __official tag names__ to add __matroska official tags__. see [here](https://www.matroska.org/technical/tagging.html)"
      ],
      "metadata": {
        "id": "IGPECvOLdQrW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mkvFile = \"\" #@param {type:\"string\"}\n",
        "saveXML = True #@param {type:\"boolean\"}\n",
        "\n",
        "import os\n",
        "from xml.etree.ElementTree import Element, tostring\n",
        "\n",
        "class mkvtagger(object):\n",
        "    def __init__(self):\n",
        "        self.tags_dict = {}\n",
        "        self.input_file = os.path.abspath(mkvFile)\n",
        "        self.__get_xml()\n",
        "\n",
        "    def __get_xml(self):\n",
        "        source_dir = os.path.dirname(self.input_file)\n",
        "        source_name = os.path.splitext(os.path.basename(self.input_file))[0]\n",
        "        self.xml_path = os.path.join(source_dir, f'{source_name}_[TagsXML].xml')\n",
        "\n",
        "    def __get_tags(self):\n",
        "        print(\"Matroska/WebM Tags\")\n",
        "        print(\"│\")\n",
        "        self.mkv_title = input(\"├── Title: \")\n",
        "        print(\"│\")\n",
        "        tags_txt = input(\"├── Do you want to add tags from a text document? [y/n] \")\n",
        "        if tags_txt.lower() in [\"y\", \"yes\"]:\n",
        "            txt_path = input(\"├── Text document's path: \")\n",
        "            print(\"│\")\n",
        "            with open(os.path.abspath(txt_path), 'r') as txt:\n",
        "                for custom_tag in txt:\n",
        "                    custom_tag = custom_tag.strip()\n",
        "                    tag_name = custom_tag.split(\":\")[0]\n",
        "                    tag_name = tag_name.strip()\n",
        "                    tag_values = custom_tag.split(\":\")[1]\n",
        "                    tag_values = tag_values.split(\",\")\n",
        "\n",
        "                    i = 0\n",
        "                    for value in tag_values:\n",
        "                        value = value.strip()\n",
        "                        tag_values[i] = value\n",
        "                        i += 1\n",
        "\n",
        "                    tag_value = \", \".join(tag_values)\n",
        "                    self.tags_dict[tag_name] = tag_value\n",
        "                    print(f\"├── {tag_name}: {tag_value}\")\n",
        "        elif tags_txt.lower() in [\"n\", \"no\"]:\n",
        "            print(\"│\")\n",
        "            print(\"├── Type [tag name] first and [tag value] second.\")\n",
        "            print(\"├── When finished, leave 'Tag name: ' as blank.\")\n",
        "            print(\"│\")\n",
        "\n",
        "            while True:\n",
        "                tag_name = input(\"├── Tag name: \")\n",
        "                if tag_name == \"\":\n",
        "                    break\n",
        "                else:\n",
        "                    tag_value = input(f'├── {tag_name}: ')\n",
        "                    self.tags_dict[tag_name] = tag_value\n",
        "        else:\n",
        "            print('│\\n└── Input is invalid. Try again...')\n",
        "            print()\n",
        "            return \"error\"\n",
        "\n",
        "    def __create_xml(self):\n",
        "        node_tags = Element('Tags')\n",
        "        node_tag = Element('Tag')\n",
        "        for name, value in self.tags_dict.items():\n",
        "            node_simple = Element('Simple')\n",
        "            node_name = Element('Name')\n",
        "            node_name.text = name\n",
        "            node_simple.append(node_name)\n",
        "            node_string = Element('String')\n",
        "            node_string.text = value\n",
        "            node_simple.append(node_string)\n",
        "            node_tag.append(node_simple)\n",
        "        node_tags.append(node_tag)\n",
        "        xml_data = tostring(node_tags)\n",
        "\n",
        "        with open(self.xml_path, 'wb') as xml:\n",
        "            xml.write(xml_data)\n",
        "\n",
        "    def get_start(self):\n",
        "        t = self.__get_tags()\n",
        "        self.__create_xml()\n",
        "\n",
        "        if t != \"error\":\n",
        "            command_line = f'\"{self.input_file}\" --tags all:\"{self.xml_path}\" --edit info '\n",
        "\n",
        "            if not self.mkv_title: command_line += \"--delete title \"\n",
        "            else: command_line += f'--set title=\"{self.mkv_title}\" '\n",
        "\n",
        "            print(\"│\")\n",
        "            encoded_date = input('├── Do you want to remove encoded date? [y/n] ')\n",
        "            writing_application = input('├── Do you want to remove writing application? [y/n] ')\n",
        "            writing_library = input('└── Do you want to remove writing library? [y/n] ')\n",
        "            print()\n",
        "\n",
        "            if encoded_date in [\"y\", \"yes\"]: command_line += \"--delete date \"\n",
        "            if writing_application in [\"y\", \"yes\"]: command_line += '--set writing-application=\"\" '\n",
        "            if writing_library in [\"y\", \"yes\"]: command_line += '--set muxing-application=\"\" '\n",
        "\n",
        "            if not saveXML: os.remove(self.xml_path)\n",
        "            return command_line\n",
        "\n",
        "mkv_tagger = mkvtagger()\n",
        "print()\n",
        "!mkvpropedit {mkv_tagger.get_start()}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "nYI7RohZ58e5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __Mutagen__"
      ],
      "metadata": {
        "id": "mdWwCc8AApIn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Mutagen is a python based multimedia **tagging** library.\n",
        "* Run below cell to **install** Mutagen."
      ],
      "metadata": {
        "id": "ZTBATlO3AsJu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/Essential-Google-Colab-Notebook/0b62cd8a437d3439a1dbece9119b73bfa890ad1a/cell_logos/Mutagen-Logo.svg' height=\"70\" alt=\"mutagen-logo\"/></center>\n",
        "#@markdown <center><h3><b>Install Mutagen</b></h3></center><br>\n",
        "from IPython.display import clear_output\n",
        "!python3 -m pip install mutagen\n",
        "clear_output()\n",
        "print(\"Successfully Installed.\")"
      ],
      "metadata": {
        "id": "nJdQOavpA_4g",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __FLAC__"
      ],
      "metadata": {
        "id": "NZHz6WkUBGKg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Enter **FLAC** file path in `inputFLAC`.\n",
        "* If you want to add **multiple values**, separate tags by a **comma** and a **space**.\n",
        "> `Eg: Artist: Artist1, Artist2, Artist3`\n",
        "* You can add **more custom tags** using a **text file**. Text file's content must be as formatted as below.\n",
        "> `Tag name 1: Tag value 1, Tag value 2, Tag value 3`<br>\n",
        "> `Tag name 2: Tag value 1, Tag value 2, Tag value 3`<br>\n",
        "* Explainations are available while running the cell."
      ],
      "metadata": {
        "id": "Afkres2x3aeN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputFLAC = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import os\n",
        "from mutagen.flac import Picture, FLAC\n",
        "\n",
        "taggerFLAC = FLAC(os.path.abspath(inputFLAC))\n",
        "tagMode = input(f'mutagenFLAC\\n|\\n|-- 1 : Add tags\\n|-- 2 : Remove tags\\n|\\n|--tagMode: [1/2] ')\n",
        "\n",
        "if tagMode == '2':\n",
        "    taggerFLAC.delete()\n",
        "    print(f'\\nAll tags are successfully removed, but Covers/Albumarts are still remain.')\n",
        "    removeCovers = input(f'Do you want to remove all Covers/Albumarts? [y/n] ')\n",
        "    if (removeCovers.lower() == \"y\") or (removeCovers.lower() == \"yes\"):\n",
        "        taggerFLAC.clear_pictures()\n",
        "        print(f'Covers/Albumarts are successfully removed.')\n",
        "    elif (removeCovers.lower() == \"\") or (removeCovers.lower() == \"n\") or (removeCovers.lower() == \"no\"):\n",
        "        print(f'Covers/Albumarts are still available.')\n",
        "\n",
        "elif tagMode == '1':\n",
        "    print('\\n' + os.path.basename(os.path.abspath(inputFLAC)), '\\n|')\n",
        "    Title = input(f'|--Title: ')\n",
        "    Album = input(f'|--Album: ')\n",
        "    Artist = input(f'|--Artist: ')\n",
        "    albumArtist = input(f'|--Album Artist: ')\n",
        "    releaseDate = input(f'|--Release Date: ')\n",
        "    Composer = input(f'|--Composer: ')\n",
        "    Lyricist = input(f'|--Lyricist: ')\n",
        "    Genre = input(f'|--Genre: ')\n",
        "    discNumber = input(f'|--Disc No.: ')\n",
        "    discTotal = input(f'|--Disc Total: ')\n",
        "    trackNumber = input(f'|--Track No.: ')\n",
        "    trackTotal = input(f'|--Track Total: ')\n",
        "    Copyright = input(f'|--Copyright: ')\n",
        "    isrc = input(f'|--ISRC: ')\n",
        "\n",
        "    taggerFLAC['title'] = Title.split(', ')\n",
        "    taggerFLAC['album'] = Album.split(', ')\n",
        "    taggerFLAC['artist'] = Artist.split(', ')\n",
        "    taggerFLAC['albumartist'] = albumArtist.split(', ')\n",
        "    taggerFLAC['date'] = releaseDate.split(', ')\n",
        "    taggerFLAC['composer'] = Composer.split(', ')\n",
        "    taggerFLAC['Lyricist'] = Lyricist.split(', ')\n",
        "    taggerFLAC['genre'] = Genre.split(', ')\n",
        "    taggerFLAC['discnumber'] = discNumber.split(', ')\n",
        "    taggerFLAC['totaldiscs'] = discTotal.split(', ')\n",
        "    taggerFLAC['tracknumber'] = trackNumber.split(', ')\n",
        "    taggerFLAC['totaltracks'] = trackTotal.split(', ')\n",
        "    taggerFLAC['copyright'] = Copyright.split(', ')\n",
        "    taggerFLAC['isrc'] = isrc.split(', ')\n",
        "\n",
        "    Rating = input(f'|\\n|-- 1 : None\\n|-- 2 : Clean\\n|-- 3 : Explicit\\n|\\n|--Rating: [1/2/3] ')\n",
        "    if Rating == '3':\n",
        "        taggerFLAC['rating'] = ['Explicit']\n",
        "    elif Rating == '2':\n",
        "        taggerFLAC['rating'] = ['Clean']\n",
        "    elif Rating == '1':\n",
        "        taggerFLAC['rating'] = []\n",
        "    else:\n",
        "        print(\"|--Invalid input is detected. So, Ignoring the Rating tag.\")\n",
        "\n",
        "    addLyrics = input(f\"|\\n|--Do you want to add 'Lyrics'? [y/n] \")\n",
        "    if (addLyrics.lower() == 'y') or (addLyrics.lower() == 'yes'):\n",
        "        lrcDoc = input(f\"|--Save lyrics in a text document and enter it's path\\n|--Text document's path: \")\n",
        "        Lyrics = open(lrcDoc, 'r').read()\n",
        "        taggerFLAC[\"lyrics\"] = Lyrics\n",
        "    else:\n",
        "        print(\"|--No 'Lyrics' added!\")\n",
        "\n",
        "    addCustomTags = input(f\"|\\n|--Do you want to add more 'Custom Tags'? [y/n] \")\n",
        "    if (addCustomTags.lower() == 'y') or (addCustomTags.lower() == 'yes'):\n",
        "        addTextDoc = input(f'|--Do you want to add tags from a text document? [y/n] ')\n",
        "        if (addTextDoc.lower() == 'n') or (addTextDoc.lower() == 'no'):\n",
        "            print(f'|\\n|--Type [tag name] first and [tag value] second')\n",
        "            print(f\"|--When finished, Type 'done' in [tag name]\\n|\")\n",
        "            while True:\n",
        "                tagName = input(f'|--Tag name: ')\n",
        "                if tagName.lower() == \"done\":\n",
        "                    break\n",
        "                tagValue = input(f'|--{tagName}: ')\n",
        "                taggerFLAC[tagName] = tagValue.split(', ')\n",
        "        elif (addTextDoc.lower() == 'y') or (addTextDoc.lower() == 'yes'):\n",
        "            textDoc = input(f\"|--Text document's path: \")\n",
        "            print(f'|')\n",
        "            with open(textDoc) as textTags:\n",
        "                for customTags in textTags:\n",
        "                    customTags = customTags.strip()\n",
        "                    print(f'|--{customTags}')\n",
        "                    tagName = customTags.split(': ')\n",
        "                    tagValue = tagName[1].split(', ')\n",
        "                    taggerFLAC[tagName[0]] = [value for value in tagValue]\n",
        "    else:\n",
        "        print(f\"|--No 'Custom Tags' added!\")\n",
        "\n",
        "    addCover = input(f\"|\\n|--Do you want to add a 'Cover'? [y/n] \")\n",
        "    if (addCover.lower() == 'y') or (addCover.lower() == 'yes'):\n",
        "        albumart = input(f\"|--Cover's file path: \")\n",
        "        image = Picture()\n",
        "        image.type = 3\n",
        "        if os.path.splitext(albumart)[1] == '.png':\n",
        "            image.mime = 'image/png'\n",
        "        elif (os.path.splitext(albumart)[1] == '.jpg') or (os.path.splitext(albumart)[1] == '.jpeg'):\n",
        "            image.mime = 'image/jpeg'\n",
        "        with open(albumart, 'rb') as coverFile:\n",
        "            image.data = coverFile.read()\n",
        "        taggerFLAC.add_picture(image)\n",
        "    else:\n",
        "        print(f\"|--No 'Cover' added!\")\n",
        "    taggerFLAC.pprint()\n",
        "    taggerFLAC.save()\n",
        "    print(f'|\\n|--Successfully Tagged')\n",
        "else:\n",
        "    print(f'|--Invalid response, Try again....')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "hZYgIBLN5ojb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __MP4 / M4A__"
      ],
      "metadata": {
        "id": "SKc4EqkfLvbk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Enter **MP4/M4A** file path in `inputMP4`.\n",
        "* If you want to add **multiple values**, separate tags by a **comma** and a **space**.\n",
        "> `Eg: Artist: Artist1, Artist2, Artist3`\n",
        "* You can add **more custom tags** using a **text file**. Text file's content must be as formatted as below.\n",
        "> `Tag name 1: Tag value 1, Tag value 2, Tag value 3`<br>\n",
        "> `Tag name 2: Tag value 1, Tag value 2, Tag value 3`<br>\n",
        "* Explainations are available while running the cell."
      ],
      "metadata": {
        "id": "YaLRJPT_Uw-w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputMP4 = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import os\n",
        "from mutagen.mp4 import MP4\n",
        "from mutagen.mp4 import MP4Cover\n",
        "\n",
        "taggerMP4 = MP4(inputMP4)\n",
        "tagMode = input(f'mutagenMP4\\n|\\n|-- 1 : Add tags\\n|-- 2 : Remove tags\\n|\\n|--tagMode: [1/2] ')\n",
        "\n",
        "if tagMode == '2':\n",
        "    taggerMP4.delete()\n",
        "    taggerMP4.save()\n",
        "    print(f\"|\\n|--All 'Tags' and 'Covers' are successfully removed!\")\n",
        "\n",
        "elif tagMode == '1':\n",
        "    print('\\n' + os.path.basename(os.path.abspath(inputMP4)), '\\n|')\n",
        "    Title = input(\"|--Title: \")\n",
        "    Album = input(\"|--Album: \")\n",
        "    Artist = input(\"|--Artist: \")\n",
        "    albumArtist = input(\"|--Album Artist: \")\n",
        "    Genre = input(\"|--Genre: \")\n",
        "    releasedDate = input(\"|--Released Date: \")\n",
        "    Composer = input(\"|--Composer: \")\n",
        "    Comment = input(\"|--Comment: \")\n",
        "    Grouping = input(\"|--Grouping: \")\n",
        "    Copyright = input(\"|--Copyright: \")\n",
        "\n",
        "    taggerMP4['aART'] = albumArtist.split(', ')\n",
        "    taggerMP4['cprt'] = Copyright.split(', ')\n",
        "    taggerMP4['\\xa9nam'] = Title.split(', ')\n",
        "    taggerMP4['\\xa9alb'] = Album.split(', ')\n",
        "    taggerMP4['\\xa9ART'] = Artist.split(', ')\n",
        "    taggerMP4['\\xa9gen'] = Genre.split(', ')\n",
        "    taggerMP4['\\xa9day'] = releasedDate.split(', ')\n",
        "    taggerMP4['\\xa9wrt'] = Composer.split(', ')\n",
        "    taggerMP4['\\xa9cmt'] = Comment.split(', ')\n",
        "    taggerMP4['\\xa9grp'] = Grouping.split(', ')\n",
        "\n",
        "    Rating = input(f'|\\n|-- 0 : None\\n|-- 2 : Clean\\n|-- 4 : Explicit\\n|\\n|--Rating: [0/2/4] ')\n",
        "    if not Rating:\n",
        "        taggerMP4['rtng'] =[]\n",
        "    else:\n",
        "        taggerMP4['rtng'] = [int(Rating)]\n",
        "\n",
        "    contentType = input(f'|\\n|-- 0  : Movie\\n|-- 1  : Music\\n|-- 2  : Audiobook\\n|-- 5  : Whacked Bookmark\\n|-- 6  : Music Video\\n|-- 9  : Short Film\\n|-- 10 : TV Show\\n|-- 11 : Booklet\\n|-- 14 : Ringtone\\n|\\n|--ContentType: [0/1/2/5/6/9/10/11/14] ')\n",
        "    if not contentType:\n",
        "        taggerMP4['stik'] = []\n",
        "    else:\n",
        "        taggerMP4['stik'] = [int(contentType)]\n",
        "\n",
        "    Work = input(\"|\\n|--Work: \")\n",
        "    Movemonet = input(\"|--Movemonet: \")\n",
        "    Description = input(\"|--Description: \")\n",
        "    longDescription = input(\"|--LongDescription: \")\n",
        "\n",
        "    taggerMP4['\\xa9wrk'] = Work.split(', ')\n",
        "    taggerMP4['\\xa9mvn'] = Movemonet.split(', ')\n",
        "    taggerMP4['desc'] = Description.split(', ')\n",
        "    taggerMP4['ldes'] = longDescription.split(', ')\n",
        "\n",
        "    trackNumber = input(\"|--Track No.: \")\n",
        "    trackTotal = input(\"|--Track Total: \")\n",
        "\n",
        "    if not trackNumber:\n",
        "        if not trackTotal:\n",
        "            taggerMP4['trkn'] = []\n",
        "        else:\n",
        "            taggerMP4['trkn'] = [(0, int(trackTotal))]\n",
        "    else:\n",
        "        if not trackTotal:\n",
        "            taggerMP4['trkn'] = [(int(trackNumber), 0)]\n",
        "        else:\n",
        "            taggerMP4['trkn'] = [(int(trackNumber), int(trackTotal))]\n",
        "\n",
        "    diskNumber = input(\"|--Disk No.: \")\n",
        "    discTotal = input(\"|--Disk Total: \")\n",
        "\n",
        "    if not diskNumber:\n",
        "        if not discTotal:\n",
        "            taggerMP4['disk'] = []\n",
        "        else:\n",
        "            taggerMP4['disk'] = [(0, int(discTotal))]\n",
        "    else:\n",
        "        if not discTotal:\n",
        "            taggerMP4['disk'] = [(int(diskNumber), 0)]\n",
        "        else:\n",
        "            taggerMP4['disk'] = [(int(diskNumber), int(discTotal))]\n",
        "\n",
        "    if contentType == '10':\n",
        "        tvShowName = input(\"|--TV Show name: \")\n",
        "        tvShowSeason = input(\"|--TV Show Season: \")\n",
        "        tvShowEP = input(\"|--TV Show Episode: \")\n",
        "\n",
        "        taggerMP4['tvsh'] = tvShowName.split(', ')\n",
        "        if not tvShowEP:\n",
        "            taggerMP4['tves'] = []\n",
        "        else:\n",
        "            taggerMP4['tves'] = [int(tvShowEP)]\n",
        "        if not tvShowSeason:\n",
        "            taggerMP4['tvsn'] = []\n",
        "        else:\n",
        "            taggerMP4['tvsn'] = [int(tvShowSeason)]\n",
        "\n",
        "    addLyrics = input(f\"|\\n|--Do you want to add 'Lyrics'? [y/n] \")\n",
        "    if (addLyrics.lower() == 'y') or (addLyrics.lower() == 'yes'):\n",
        "        lrcDoc = input(f\"|--Save lyrics in a text document and enter it's path\\n|--Text document's path: \")\n",
        "        Lyrics = open(lrcDoc, 'r').read()\n",
        "        taggerMP4[\"\\xa9lyr\"] = Lyrics\n",
        "    else:\n",
        "        print(\"|--No 'Lyrics' added!\")\n",
        "\n",
        "    addCustomTags = input(f\"|\\n|--Do you want to add more 'Custom Tags'? [y/n] \")\n",
        "    if (addCustomTags.lower() == 'y') or (addCustomTags.lower() == 'yes'):\n",
        "        addTextDoc = input(f'|--Do you want to add tags from a text document? [y/n] ')\n",
        "        if (addTextDoc.lower() == 'y') or (addTextDoc.lower() == 'yes'):\n",
        "            textDoc = input(f\"|--Text document's path: \")\n",
        "            print(f'|')\n",
        "            with open(textDoc) as textTags:\n",
        "                for customTags in textTags:\n",
        "                    customTags = customTags.strip()\n",
        "                    print(f'|--{customTags}')\n",
        "                    tagName = customTags.split(': ')\n",
        "                    tagValue = tagName[1].split(', ')\n",
        "                    taggerMP4['----:com.apple.itunes:' + tagName[0]] = [value.encode() for value in tagValue]\n",
        "        elif (addTextDoc.lower() == 'n') or (addTextDoc.lower() == 'no'):\n",
        "            print(f'|\\n|--Type [tag name] first and [tag value] second')\n",
        "            print(f\"|--When finished, Type 'done' in [tag name]\\n|\")\n",
        "            while True:\n",
        "                tagName = input(f'|--Tag name: ')\n",
        "                if tagName.lower() == \"done\":\n",
        "                    break\n",
        "                tagValue = input(f'|--{tagName}: ')\n",
        "                taggerMP4['----:com.apple.itunes:' + tagName] = [value.encode() for value in tagValue.split(', ')]\n",
        "    else:\n",
        "        print(f\"|--No 'Custom Tags' added!\")\n",
        "\n",
        "    addCover = input(f\"|\\n|--Do you want to add a 'Cover'? [y/n] \")\n",
        "    if (addCover.lower() == 'y') or (addCover.lower() == 'yes'):\n",
        "        albumart = input(f\"|--Cover's file path: \")\n",
        "        data = open(albumart, 'rb').read()\n",
        "        coverFile = []\n",
        "        if os.path.splitext(albumart)[1] == '.png':\n",
        "            coverFile.append(MP4Cover(data, MP4Cover.FORMAT_PNG))\n",
        "        elif (os.path.splitext(albumart)[1] == '.jpg') or (os.path.splitext(albumart)[1] == '.jpeg'):\n",
        "            coverFile.append(MP4Cover(data, MP4Cover.FORMAT_JPEG))\n",
        "        taggerMP4['covr'] = coverFile\n",
        "    else:\n",
        "        print(f\"|--No 'Cover' added!\")\n",
        "    taggerMP4.save()\n",
        "    print(f'|\\n|--Successfully Tagged')\n",
        "else:\n",
        "    print(f'|--Invalid response, Try again....')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Yib8y_LdUM2J"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}