MKVToolNix-in-Google-Colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMVtOfxNUVj0oA3wCfHLjW/",
      "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/MKVToolNix-in-Google-Colab/blob/main/MKVToolNix-in-Google-Colab.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": "tpPY4m7on3Kt"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "iSp5IM5Qnpax"
      },
      "outputs": [],
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/MKVToolNix-in-Google-Colab/main/Google-Drive-Logo.svg' height=\"50\" alt=\"Gdrive-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",
        "\n",
        "drive.mount._DEBUG = False\n",
        "\n",
        "if Mode == \"Mount\":\n",
        "    drive.mount('/content/drive', force_remount=True)\n",
        "\n",
        "elif Mode == \"Unmount\":\n",
        "    try:\n",
        "        drive.flush_and_unmount()\n",
        "    except ValueError:\n",
        "        pass\n",
        "    get_ipython().system_raw(\"rm -rf /root/.config/Google/DriveFS\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# __MKVToolNix__"
      ],
      "metadata": {
        "id": "B6LAJCgCoAJ8"
      }
    },
    {
      "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": "u71dEFKaoDmD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/dropcreations/MKVToolNix-in-Google-Colab/main/MKVToolNix-Logo.png' 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": {
        "cellView": "form",
        "id": "zpswo4hzoGWL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __mkvmerge__"
      ],
      "metadata": {
        "id": "oF7MVTCpoP3r"
      }
    },
    {
      "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": "hmAiKh-QoS8D"
      }
    },
    {
      "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": "AdykP64AoVrC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __mkvextract__"
      ],
      "metadata": {
        "id": "6pSfPzpvoZhT"
      }
    },
    {
      "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": "RItcuvkEobmM"
      }
    },
    {
      "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": "ozXBsr91od_6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __mkvpropedit__"
      ],
      "metadata": {
        "id": "fKmlX5v-ogty"
      }
    },
    {
      "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": "Mnmf5LHiojfD"
      }
    },
    {
      "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": "BJ_Ny5Z6omvD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### __Matroska/WebM Tags__"
      ],
      "metadata": {
        "id": "DghT6NtFfR56"
      }
    },
    {
      "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": "YHHyNR8yfUUR"
      }
    },
    {
      "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": "v66UqyFsfYAh"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}