Unit3Dup 0.9.11__tar.gz → 0.9.13__tar.gz

{unit3dup-0.9.11 → unit3dup-0.9.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.11
+Version: 0.9.13
 Summary: An uploader for the Unit3D torrent tracker
 Author: Parzival
 License-Expression: MIT
@@ -60,8 +60,8 @@ It performs the following tasks:
 - Seeding in qBittorrent, Transmission or rTorrent
 - Reseeding one or more torrents at a time
 - Seed your torrents across different OS
-- Add a custom title to your seasons
-- Generate info for a title using MediaInfo
+- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``, ``video_encoder``
+
 
 unit3dup can grab the first page, convert it to an image (using xpdf),
 and then the bot can upload it to an image host, then add the link to the torrent page description.

{unit3dup-0.9.11 → unit3dup-0.9.13}/README.rst

@@ -29,8 +29,8 @@ It performs the following tasks:
 - Seeding in qBittorrent, Transmission or rTorrent
 - Reseeding one or more torrents at a time
 - Seed your torrents across different OS
-- Add a custom title to your seasons
-- Generate info for a title using MediaInfo
+- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``, ``video_encoder``
+
 
 unit3dup can grab the first page, convert it to an image (using xpdf),
 and then the bot can upload it to an image host, then add the link to the torrent page description.

{unit3dup-0.9.11 → unit3dup-0.9.13}/Unit3Dup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.11
+Version: 0.9.13
 Summary: An uploader for the Unit3D torrent tracker
 Author: Parzival
 License-Expression: MIT
@@ -60,8 +60,8 @@ It performs the following tasks:
 - Seeding in qBittorrent, Transmission or rTorrent
 - Reseeding one or more torrents at a time
 - Seed your torrents across different OS
-- Add a custom title to your seasons
-- Generate info for a title using MediaInfo
+- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``, ``video_encoder``
+
 
 unit3dup can grab the first page, convert it to an image (using xpdf),
 and then the bot can upload it to an image host, then add the link to the torrent page description.

{unit3dup-0.9.11 → unit3dup-0.9.13}/Unit3Dup.egg-info/SOURCES.txt

@@ -18,8 +18,8 @@ common/extractor.py
 common/frames.py
 common/mediainfo.py
 common/mediainfo_string.py
-common/p2p_tags.py
 common/settings.py
+common/tags.py
 common/title.py
 common/torrent_clients.py
 common/utility.py

{unit3dup-0.9.11 → unit3dup-0.9.13}/common/command.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
-
 import os
 import argparse
 from common.utility import System
 from common.settings import Load
 
+
 class CommandLine:
     """
     Class to handle user input from the command line
@@ -27,9 +27,9 @@ class CommandLine:
         parser.add_argument("-u", "--upload", type=str, help="Upload path")
         parser.add_argument("-f", "--folder", type=str, help="Upload folder")
         parser.add_argument("-scan", "--scan", type=str, help="Scan folder")
+        parser.add_argument("-b", "--buildtags", action="store_true", help="Auto build torrent name")
 
         parser.add_argument("-reseed", "--reseed", action="store_true", help="reseed folder")
-        parser.add_argument("-gentitle", "--gentitle", action="store_true", help="")
         parser.add_argument("-watcher", "--watcher", action="store_true", help="Start watcher")
 
         parser.add_argument("-notitle", "--notitle", type=str, help="")
@@ -40,19 +40,19 @@ class CommandLine:
         parser.add_argument('-force', nargs='?', const="movie", type=str, default=None)
         parser.add_argument("-noseed", "--noseed", action="store_true", help="No seeding after upload")
         parser.add_argument("-noup", "--noup", action="store_true", help="Torrent only. No upload")
-        parser.add_argument("-duplicate", "--duplicate", action="store_true", help="Find duplicates")
+        parser.add_argument("-dup", "--duplicate", action="store_true", help="Find duplicates")
         parser.add_argument("-personal", "--personal", action="store_true", help="Set to personal release")
 
         parser.add_argument("-ftp", "--ftp", action="store_true", help="Connect to FTP")
 
         # optional
-        parser.add_argument("-dump", "--dump", action="store_true", help="Download all torrent titles")
-        parser.add_argument("-s", "--search", type=str, help="Search for torrent")
+        parser.add_argument("-dmp", "--dump", action="store_true", help="Download all torrent titles")
+        parser.add_argument("-sch", "--search", type=str, help="Search for torrent")
         parser.add_argument("-db", "--dbsave", action="store_true", help="Save the search results")
         parser.add_argument("-i", "--info", type=str, help="Get info on torrent")
         parser.add_argument("-up", "--uploader", type=str, help="Search by uploader")
-        parser.add_argument("-desc", "--description", type=str, help="Search by description")
-        parser.add_argument("-bdinfo", "--bdinfo", type=str, help="Show BDInfo")
+        parser.add_argument("-d", "--description", type=str, help="Search by description")
+        parser.add_argument("-bd", "--bdinfo", type=str, help="Show BDInfo")
         parser.add_argument("-m", "--mediainfo", type=str, help="Show MediaInfo")
         parser.add_argument("-st", "--startyear", type=str, help="Start year")
         parser.add_argument("-en", "--endyear", type=str, help="End year")
@@ -68,8 +68,8 @@ class CommandLine:
         parser.add_argument("-playid", "--playlist_id", type=str, help="Playlist ID")
         parser.add_argument("-coll", "--collection_id", type=str, help="Collection ID")
         parser.add_argument("-free", "--freelech", type=str, help="Freelech discount")
-        parser.add_argument("-a", "--alive", action="store_true", help="Alive torrent")
-        parser.add_argument("-d", "--dead", action="store_true", help="Dead torrent")
+        parser.add_argument("-al", "--alive", action="store_true", help="Alive torrent")
+        parser.add_argument("-dd", "--dead", action="store_true", help="Dead torrent")
         parser.add_argument("-dy", "--dying", action="store_true", help="Dying torrent")
 
         parser.add_argument(
@@ -98,8 +98,6 @@ class CommandLine:
             "-pr", "--prelease", action="store_true", help="Personal release torrent"
         )
 
-
-
         # Parsing the User cli
         self.args: parser = parser.parse_args()
 
@@ -113,10 +111,10 @@ class CommandLine:
         # Test -force flag
         if self.args.force:
             self.args.force = self.args.force[:10]
-            if self.args.force.lower() not in [ System.category_list[System.MOVIE],
-                                        System.category_list[System.GAME],
-                                        System.category_list[System.TV_SHOW],
-                                        System.category_list[System.DOCUMENTARY]]:
+            if self.args.force.lower() not in [System.category_list[System.MOVIE],
+                                               System.category_list[System.GAME],
+                                               System.category_list[System.TV_SHOW],
+                                               System.category_list[System.DOCUMENTARY]]:
                 self.args.force = None
                 print("Invalid -force category")
-                exit()
+                exit()

{unit3dup-0.9.11 → unit3dup-0.9.13}/common/settings.py

@@ -15,7 +15,8 @@ from common.utility import ManageTitles
 from common import trackers
 
 config_file = "Unit3Dbot.json"
-version = "0.9.11"
+user_tags_file = "tags_list.json"
+version = "0.9.13"
 
 if os.name == "nt":
     WATCHER_DESTINATION_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / "watcher_destination_path"
@@ -23,6 +24,7 @@ if os.name == "nt":
     CACHE_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / "cache_path"
     TORRENT_ARCHIVE_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / "torrent_archive_path"
     DEFAULT_JSON_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / f"{config_file}"
+    USER_TAGS_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / f"{user_tags_file}"
 
 else:
     WATCHER_DESTINATION_PATH: Path = Path.home() / "Unit3Dup_config" / "watcher_destination_path"
@@ -30,7 +32,7 @@ else:
     CACHE_PATH: Path = Path.home() / "Unit3Dup_config" / "cache_path"
     TORRENT_ARCHIVE_PATH: Path = Path.home() / "Unit3Dup_config" / "torrent_archive_path"
     DEFAULT_JSON_PATH: Path = Path.home() / "Unit3Dup_config" / f"{config_file}"
-
+    USER_TAGS_PATH: Path = Path.home() / "Unit3Dup_config" / f"{user_tags_file}"
 
 def get_default_path(field: str)-> str:
     default_paths = {
@@ -250,12 +252,13 @@ class Validate:
             print(f"-> Invalid TAG position. The list is empty !")
             exit(1)
 
-        if len(position_list) != 9:
+        if len(position_list) > 17 or len(position_list) < 5:
             print(f"-> Invalid TAG position list. Wrong number of elements !")
             exit(1)
 
         for tag in position_list:
-            if tag.lower() not in ["version","resolution", "platform","source", "audio", "channels", "flag", "subtitle", "video"]:
+            if tag.lower() not in ["title", "year", "season", "version", "resolution", "uhd", "platform", "source", "remux",
+                                   "multi", "acodec", "channels", "flag", "subtitle", "vcodec", "hdr", "video_encoder"]:
                 print(f"-> Invalid TAG position '{tag}'. Please fix your configuration file")
                 exit(1)
 
@@ -521,6 +524,92 @@ class Load:
     def _load_config(self):
         self.config = self.load_config()
 
+    @staticmethod
+    def create_tags_list_file(path: Path):
+        """
+        Creates a tags list file
+        """
+        TAG_TYPES = {
+            "REMUX": "remux",
+            "WEB-DL": "source",
+            "WEB-DLMUX": "source",
+            "WEBMUX": "source",
+            "WEBRIP": "source",
+            "BD-UNTOUCHED": "source",
+            "TS": "source",
+            "CAM": "source",
+            "HDTS": "source",
+            "MD": "source",
+            "UHDRIP": "source",
+            "BLURAY": "source",
+            "BRRIP": "source",
+            "BDRIP": "source",
+            "FHDRIP": "source",
+
+            "ATVP": "platform",
+            "AMZN": "platform",
+            "AMC": "platform",
+            "CN": "platform",
+            "CR": "platform",
+            "DCU": "platform",
+            "DISC": "platform",
+            "DSCP": "platform",
+            "DSNY": "platform",
+            "DSNP": "platform",
+            "DPLY": "platform",
+            "ESPN": "platform",
+            "FOOD": "platform",
+            "FOX": "platform",
+            "PLAY": "platform",
+            "HBO": "platform",
+            "HMAX": "platform",
+            "HGTV": "platform",
+            "HIST": "platform",
+            "HULU": "platform",
+            "MTOD": "platform",
+            "NATG": "platform",
+            "NF": "platform",
+            "NICK": "platform",
+            "NOW": "platform",
+            "PMNT": "platform",
+            "PMTP": "platform",
+            "PCOK": "platform",
+            "RKTN": "platform",
+            "SHO": "platform",
+            "SKST": "platform",
+            "STAN": "platform",
+            "STRP": "platform",
+            "STZ": "platform",
+            "TIMV": "platform",
+
+            "REPACK": "version",
+            "EXTENDED": "version",
+            "SUBBED": "version",
+            "MUX": "version",
+            "REMASTERED": "version",
+            "READNFO": "version",
+            "UNRATED": "version",
+            "LIMITED": "version",
+            "VU": "version",
+            "STV": "version",
+            "RECODE": "version",
+            "INTERNAL": "version",
+            "PROPER": "version",
+            "DUAL": "version",
+            "UNTOUCHED": "version",
+            "COMPLETE": "version",
+            "COMPLETA": "version",
+
+            "X264": "video_encoder",
+            "X265": "video_encoder",
+        }
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as tags_list_file:
+            json.dump(TAG_TYPES, tags_list_file, ensure_ascii=False, indent=4)
+
+
+
 
     @staticmethod
     def create_default_json_file(path: Path):
@@ -578,7 +667,8 @@ class Load:
                 "PASSIMA_PRIORITY": 5,
                 "IMARIDE_PRIORITY": 6,
                 "NUMBER_OF_SCREENSHOTS": 4,
-                "TAGS_POSITION": ["version","resolution", "platform", "source", "audio", "channels", "flag", "subtitle", "video"],
+                "TAGS_POSITION": ["title", "year", "season", "version", "resolution", "uhd", "platform", "source", "remux",
+                                  "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec", "video_encoder"],
                 "YOUTUBE_FAV_CHANNEL_ID": "UCGCbxpnt25hWPFLSbvwfg_w",
                 "YOUTUBE_CHANNEL_ENABLE": "False",
                 "DUPLICATE_ON": "true",
@@ -653,6 +743,10 @@ class Load:
             print(f"Create default configuration file: {DEFAULT_JSON_PATH}")
             Load.create_default_json_file(DEFAULT_JSON_PATH)
 
+        if not USER_TAGS_PATH.exists():
+            print(f"Create default Tags_list file: {USER_TAGS_PATH}")
+            Load.create_tags_list_file(USER_TAGS_PATH)
+
         # Since the last bot version there might are new attributes
         # Load the json file, find the difference between json file and the code. Update the user's json file
         update_config = JsonConfig(default_json_path=DEFAULT_JSON_PATH)

unit3dup-0.9.13/common/tags.py

@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+from common.mediainfo import MediaFile
+from common.utility import ManageTitles
+
+# From hdr format
+hdr_map = {
+    "DOLBY VISION": "DV",
+    "DOLBY VISION HDR": "DV HDR",
+    "DOLBY VISION HDR10": "DV HDR10",
+    "HDR10PLUS": "HDR10+",
+    "HDRPLUS+": "HDR10+",
+    "HDR10+": "HDR10+",
+    "HDR10": "HDR10",
+    "HDR10 / HDR10": "HDR10",
+    "DOVI": "DV",
+    "HDR": "HDR",
+}
+
+audio_translate = {
+    "AC3": "DD",
+    "AAC LC": "AAC",
+    "AC-3": "DD",
+    "EAC3": "DD+",
+    "E-AC3": "DD+",
+    "E-AC-3": "DD+",
+    "E-AC-3 JOC": "DD+",
+    "DTS": "DTS",
+    "DTS ES": "DTS-ES",
+    "DTS ES XLL": "DTS-HD MA",
+    "DTS XLL": "DTS-HD MA",
+    "MLP FBA 16-ch": "TrueHD",
+    "MPEG Audio": "MPEG",
+}
+
+video_translate = {
+    "AVC": "H.264",
+    "HEVC": "H.265",
+    "H265": "H.265",
+    "H264": "H.264",
+}
+
+video_encoder_translate = {
+    "X265": "x.265",
+    "X264": "x.264",
+}
+
+
+class SearchTags(object):
+    def __init__(self, filename, title: str, year: str, season: int, episode: int,
+                 mediafile: MediaFile, tags_position: list, tags_list: dict, releaser_sign: str):
+
+        self.tags_position = tags_position
+        self.releaser_sign = releaser_sign
+        self.mediafile = mediafile
+        self.filename = filename
+        self.episode = episode
+        self.season = season
+        self.title = title
+        self.year = year
+        self.tags_dict = {}
+        self.tags_position = tags_position
+        self.TAG_TYPES = tags_list
+
+    @staticmethod
+    def normalize_version_tag(tag: str) -> str:
+        tag_esc = re.escape(tag)
+        # Filter hyphenated,space compounds
+        tag_esc = tag_esc.replace(r'\ ', r'[.\s_-]*')
+        return tag_esc
+
+    @staticmethod
+    def normalize_platform_tag(tag: str) -> str:
+        # escape
+        tag_esc = re.escape(tag)
+        return tag_esc
+
+    @staticmethod
+    def normalize_sources(tag: str) -> str:
+        tag_esc = re.escape(tag)
+        # Filter hyphenated,space compounds
+        tag_esc = tag_esc.replace(r'\ ', r'[.\s_-]*')
+        return tag_esc
+
+    @staticmethod
+    def normalize_video_encoder(tag: str) -> str:
+        tag_esc = re.escape(tag)
+        tag_esc = re.sub(r'([A-Z])(\d+)', r'\1[._-]?\2', tag_esc)
+        return tag_esc
+
+    def process(self) -> str:
+        patterns = []
+
+        # loop sorted TAG_TYPES dictionary
+        for i, (tag, category) in enumerate(
+                sorted(self.TAG_TYPES.items(), key=lambda x: len(x[0]), reverse=True)
+        ):
+            if category == "version":
+                norm = self.normalize_version_tag(tag)
+            elif category == "platform":
+                norm = self.normalize_platform_tag(tag)
+            elif category == "source":
+                norm = self.normalize_sources(tag)
+            elif category == "video_encoder":
+                norm = self.normalize_video_encoder(tag)
+            else:
+                norm = re.escape(tag)
+                # Save a regex pattern for each category
+            patterns.append([norm, category])
+
+        # Run regex
+        for p, category in patterns:
+            regex = re.compile(r'(?<!\w)' + p + r'(?!\w)', re.IGNORECASE)
+            matches = regex.findall(self.filename)
+            if matches:
+                self.tags_dict.setdefault(category, []).append(matches[0])
+
+        # /// Read from mediainfo
+        updated_category = {}
+        for category in self.tags_position:
+            if category == "acodec":
+                updated_category = self.mediainfo_audio(category=category)
+
+            elif category == "vcodec":
+                updated_category = self.mediainfo_video(category=category)
+
+            elif category == "hdr":
+                updated_category = self.mediainfo_hdr(category=category)
+
+            elif category == "uhd":
+                updated_category = self.mediainfo_uhd(category=category)
+
+            elif category == "subtitle":
+                if self.mediafile.subtitle_track:
+                    updated_category = {'subtitle': "SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB"}
+
+            if updated_category:
+                self.tags_dict.update(updated_category)
+
+        # /// Add S#E#, title, Year
+        se_str = ''
+        if self.season is not None and self.episode is not None:
+            se_str = f"S{self.season:02d}E{self.episode:02d}"
+        elif self.season is not None:
+            se_str = f"S{self.season:02d}"
+        elif self.episode is not None:
+            se_str = f"E{self.episode:02d}"
+
+        self.tags_dict.update({'title': self.title})
+        if self.year:
+            self.tags_dict.update({'year': self.year})
+        if se_str:
+            self.tags_dict.update({'season': se_str})
+
+        # /// Add Sign
+        if not self.releaser_sign:
+            filename, _ = os.path.splitext(os.path.basename(self.filename))
+            m = re.search(r'-([A-Za-z0-9]+)$', filename)
+            self.releaser_sign = f"-{m.group(1)}" if m and m.group(1) not in self.TAG_TYPES else ""
+        else:
+            self.releaser_sign = f"-{self.releaser_sign}"
+
+        # /// Order according to tag position
+        tags_dict = {
+            k: self.tags_dict[k]
+            for k in self.tags_position
+            if k in self.tags_dict
+        }
+
+        # /// Build the title
+        build = []
+        for k, v in tags_dict.items():
+            if isinstance(v, list):
+                build.append(' '.join(v))
+            else:
+                build.append(str(v))
+
+        refactored = ' '.join(build) + self.releaser_sign
+        return refactored
+
+    def mediainfo_audio(self, category: str) -> dict:
+        languages = []
+        audio_codecs = []
+        if self.mediafile.audio_track:
+            for audio in self.mediafile.audio_track:
+                other_format = audio.get('other_format', [])
+                if other_format:
+                    codec_translated = audio_translate.get(other_format[0], '')
+                    if not codec_translated:
+                        codec_translated = other_format[0]
+                    # Check Atmos
+                    dolby = audio.get('commercial_name', "").lower()
+                    atmos = 'Atmos' if 'atmos' in dolby else ''
+                    # Add audio codec
+                    channel_s = audio.get('channel_s', 0)
+                    # Add channels
+                    ch = {2: "2.0", 6: "5.1", 8: "7.1"}.get(channel_s, "")
+                    if f"{codec_translated} {ch} {atmos}".strip() not in audio_codecs:
+                        audio_codecs.append(f"{codec_translated} {ch} {atmos}".strip())
+                    # print(f"Mediainfo {other_format} -> {codec_translated} {ch} {atmos}")
+
+                # Add flags
+                for l in audio.get('other_language', []):
+                    c = ManageTitles.convert_iso(l)
+                    if c:
+                        if isinstance(c, list):
+                            languages.append(c[0])
+                        else:
+                            languages.append(c)
+                        break
+                languages = list(dict.fromkeys(languages))
+                # Add multilanguage tag when languages > 2
+                if len(languages) > 2:
+                    self.tags_dict.update({'multi': 'MULTI'})
+
+            audio_codecs.extend(languages)
+        return {category: audio_codecs}
+
+    def mediainfo_video(self, category: str) -> dict:
+        codec_translated = {}
+        if self.mediafile.video_track:
+            for video in self.mediafile.video_track:
+                video_format = video.get('format', "")
+                codec_translated = video_translate.get(video_format, video_format)
+        if codec_translated:
+            return {category: codec_translated}
+        return codec_translated
+
+    def mediainfo_hdr(self, category: str) -> dict:
+        if self.mediafile.video_track:
+            for video in self.mediafile.video_track:
+                hdr_format_commercial = video.get('hdr_format_commercial', "")
+                hdr_format = video.get('hdr_format', "")
+                # Check hdr
+                if hdr_format_commercial:
+                    # print(f"hdr_format_commercial: {hdr_format_commercial}")
+                    # print(f"hdr_format: {hdr_format}")
+                    hdr = ''
+                    if hdr_format_commercial in hdr_map:
+                        # print(
+                        #     f"hdr_format_commercial: {hdr_format_commercial} -> Tag: {hdr_map[hdr_format_commercial]}")
+                        hdr = hdr_map[hdr_format_commercial]
+                        # Check dolby vision
+                    if 'DOLBY VISION' in hdr_format_commercial.upper() or 'DOLBY VISION' in hdr_format.upper():
+                        hdr = f"DOLBY VISION {hdr}"
+                        # print(hdr)
+                    return {category: hdr_map[hdr]}
+        return {}
+
+    def mediainfo_uhd(self, category: str) -> dict:
+        """
+        identify resolution based on Height and Width tolerance 5%
+        """
+        result = {}
+        if self.mediafile.video_track:
+            video_height = int(self.mediafile.video_track[0].get('height', 0))
+            video_width = int(self.mediafile.video_track[0].get('width', 0))
+
+            # print(f"VideoTrack : W{video_width} x H{video_height}")
+
+            # Calculate range 5%
+            def in_range(value, standard):
+                tol = standard * 0.05
+                return standard - tol <= value <= standard + tol
+
+            # /// UHD
+            if video_height >= 2000 or video_width >= 3840:
+                result[category] = 'UHD'
+                result['resolution'] = '2160p'
+            # /// Full HD
+            elif in_range(video_height, 1080) or in_range(video_width, 1920):
+                result[category] = 'FullHD'
+                result['resolution'] = '1080p'
+            # /// HD
+            elif in_range(video_height, 720) or in_range(video_width, 1280):
+                result[category] = 'HD'
+                result['resolution'] = '720p'
+            # /// SD 576p
+            elif in_range(video_height, 576) or in_range(video_width, 768):
+                result[category] = 'SD'
+                result['resolution'] = '576p'
+            # /// SD 480p
+            elif in_range(video_height, 480) or in_range(video_width, 640):
+                result[category] = 'SD'
+                result['resolution'] = '480p'
+            else:
+                result[category] = 'unknown'
+                result['resolution'] = f'{video_width}x{video_height}'
+
+        return result