Unit3Dup 0.9.12__tar.gz → 0.9.14__tar.gz

{unit3dup-0.9.12 → unit3dup-0.9.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.12
+Version: 0.9.14
 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.12 → unit3dup-0.9.14}/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.12 → unit3dup-0.9.14}/Unit3Dup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.12
+Version: 0.9.14
 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.12 → unit3dup-0.9.14}/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
@@ -30,7 +30,6 @@ class CommandLine:
         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="")
@@ -99,8 +98,6 @@ class CommandLine:
             "-pr", "--prelease", action="store_true", help="Personal release torrent"
         )
 
-
-
         # Parsing the User cli
         self.args: parser = parser.parse_args()
 
@@ -114,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.12 → unit3dup-0.9.14}/common/settings.py

@@ -15,7 +15,8 @@ from common.utility import ManageTitles
 from common import trackers
 
 config_file = "Unit3Dbot.json"
-version = "0.9.12"
+user_tags_file = "tags_list.json"
+version = "0.9.14"
 
 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 = {
@@ -522,6 +524,116 @@ 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",
+            "PDTV": "source",
+            "SATRIP": "source",
+            "DVBRIP": "source",
+            "DVB-S": "source",
+            "DTTRIP": "source",
+            "WP": "source",
+            "DVDSCR": "source",
+            "TVRIP": "source",
+            "VHSRIP": "source",
+            "DVDRIP": "source",
+            "HDTV": "source",
+            "DVD5": "source",
+            "DVD9": "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",
+            "EXTENDED EDITION": "version",
+            "EXTENDED CUT": "version",
+            "DIRECTOR'S CUT": "version",
+            "SUBBED": "version",
+            "MUX": "version",
+            "REMASTERED": "version",
+            "READNFO": "version",
+            "UNRATED": "version",
+            "UNCUT": "version",
+            "LIMITED": "version",
+            "ANNIVERSARY": "version",
+            "SPECIAL EDITION": "version",
+            "4k RESTORATION": "version",
+            "IMAX": "version",
+            "OPEN MATTE": "version",
+            "2IN1": "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):
@@ -580,7 +692,7 @@ class Load:
                 "IMARIDE_PRIORITY": 6,
                 "NUMBER_OF_SCREENSHOTS": 4,
                 "TAGS_POSITION": ["title", "year", "season", "version", "resolution", "uhd", "platform", "source", "remux",
-                                  "multi", "acodec", "channels", "flag", "subtitle", "vcodec", "hdr", "video_encoder"],
+                                  "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec", "video_encoder"],
                 "YOUTUBE_FAV_CHANNEL_ID": "UCGCbxpnt25hWPFLSbvwfg_w",
                 "YOUTUBE_CHANNEL_ENABLE": "False",
                 "DUPLICATE_ON": "true",
@@ -655,6 +767,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.12 → unit3dup-0.9.14}/common/tags.py

@@ -3,92 +3,21 @@ import os
 import re
 from common.mediainfo import MediaFile
 from common.utility import ManageTitles
-
-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",
-}
+from view import custom_console
 
 # From hdr format
 hdr_map = {
     "DOLBY VISION": "DV",
     "DOLBY VISION HDR": "DV HDR",
     "DOLBY VISION HDR10": "DV HDR10",
+    "DOLBY VISION HDR10+": "DV HDR",
     "HDR10PLUS": "HDR10+",
     "HDRPLUS+": "HDR10+",
     "HDR10+": "HDR10+",
     "HDR10": "HDR10",
     "HDR10 / HDR10": "HDR10",
+    "HDR10 / HDR10 / HDR10+": "HDR10+",
+
     "DOVI": "DV",
     "HDR": "HDR",
 }
@@ -96,6 +25,7 @@ hdr_map = {
 audio_translate = {
     "AC3": "DD",
     "AAC LC": "AAC",
+    "AAC LC SBR": "HE-AAC",
     "AC-3": "DD",
     "EAC3": "DD+",
     "E-AC3": "DD+",
@@ -124,7 +54,7 @@ video_encoder_translate = {
 
 class SearchTags(object):
     def __init__(self, filename, title: str, year: str, season: int, episode: int,
-                 mediafile: MediaFile, tags_position: list, releaser_sign: str):
+                 mediafile: MediaFile, tags_position: list, tags_list: dict, releaser_sign: str):
 
         self.tags_position = tags_position
         self.releaser_sign = releaser_sign
@@ -136,25 +66,30 @@ class SearchTags(object):
         self.year = year
         self.tags_dict = {}
         self.tags_position = tags_position
+        self.TAG_TYPES = tags_list
 
-    def normalize_version_tag(self, tag: str) -> str:
+    @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
 
-    def normalize_platform_tag(self, tag: str) -> str:
+    @staticmethod
+    def normalize_platform_tag(tag: str) -> str:
         # escape
         tag_esc = re.escape(tag)
         return tag_esc
 
-    def normalize_sources(self, tag: str) -> str:
+    @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
 
-    def normalize_video_encoder(self, tag: str) -> str:
+    @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
@@ -164,7 +99,7 @@ class SearchTags(object):
 
         # loop sorted TAG_TYPES dictionary
         for i, (tag, category) in enumerate(
-                sorted(TAG_TYPES.items(), key=lambda x: len(x[0]), reverse=True)
+                sorted(self.TAG_TYPES.items(), key=lambda x: len(x[0]), reverse=True)
         ):
             if category == "version":
                 norm = self.normalize_version_tag(tag)
@@ -195,6 +130,10 @@ class SearchTags(object):
             elif category == "vcodec":
                 updated_category = self.mediainfo_video(category=category)
 
+            elif category == "video_encoder":
+                if self.tags_dict.get('video_encoder', None):
+                    self.tags_dict['video_encoder'][0] = self.tags_dict['video_encoder'][0].lower()
+
             elif category == "hdr":
                 updated_category = self.mediainfo_hdr(category=category)
 
@@ -202,7 +141,8 @@ class SearchTags(object):
                 updated_category = self.mediainfo_uhd(category=category)
 
             elif category == "subtitle":
-                updated_category = {'subtitle': "SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB"}
+                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)
@@ -226,7 +166,7 @@ class SearchTags(object):
         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 TAG_TYPES else ""
+            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}"
 
@@ -249,7 +189,7 @@ class SearchTags(object):
         return refactored
 
     def mediainfo_audio(self, category: str) -> dict:
-        langs = set()
+        languages = []
         audio_codecs = []
         if self.mediafile.audio_track:
             for audio in self.mediafile.audio_track:
@@ -267,22 +207,23 @@ class SearchTags(object):
                     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}")
+                    # 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):
-                            langs.update(c)
+                            languages.append(c[0])
                         else:
-                            langs.add(c)
+                            languages.append(c)
                         break
+                languages = list(dict.fromkeys(languages))
                 # Add multilanguage tag when languages > 2
-                if len(langs) > 2:
+                if len(languages) > 2:
                     self.tags_dict.update({'multi': 'MULTI'})
 
-            audio_codecs.extend(list(langs))
+            audio_codecs.extend(languages)
         return {category: audio_codecs}
 
     def mediainfo_video(self, category: str) -> dict:
@@ -302,17 +243,19 @@ class SearchTags(object):
                 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}")
+                    # 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]}")
+                        # print(
+                        #     f"hdr_format_commercial: {hdr_format_commercial} -> Tag: {hdr_map[hdr_format_commercial]}")
                         hdr = hdr_map[hdr_format_commercial]
                         # Check dolby vision
+                    if hdr not in hdr_map:
+                        custom_console.bot_warning_log(f"<> HDR Warning: '{hdr_format_commercial}' not found in hdr_map")
                     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 {category: hdr_map.get(hdr, '*HDR')}
         return {}
 
     def mediainfo_uhd(self, category: str) -> dict:
@@ -323,7 +266,8 @@ class SearchTags(object):
         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}")
+
+            # print(f"VideoTrack : W{video_width} x H{video_height}")
 
             # Calculate range 5%
             def in_range(value, standard):
@@ -354,4 +298,4 @@ class SearchTags(object):
                 result[category] = 'unknown'
                 result['resolution'] = f'{video_width}x{video_height}'
 
-        return result
+        return result

{unit3dup-0.9.12 → unit3dup-0.9.14}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 dynamic = ["dependencies"]
 name = "Unit3Dup"
-version = "0.9.12"
+version = "0.9.14"
 description = "An uploader for the Unit3D torrent tracker"
 readme = "README.rst"
 requires-python = ">=3.10"

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/__main__.py

@@ -1,8 +1,9 @@
 # -*- coding: utf-8 -*-
+import json
 
 from common.torrent_clients import TransmissionClient, QbittorrentClient, RTorrentClient
 from common.command import CommandLine
-from common.settings import Load,DEFAULT_JSON_PATH
+from common.settings import Load,DEFAULT_JSON_PATH, USER_TAGS_PATH
 
 from unit3dup.torrent import View
 from unit3dup import pvtTracker
@@ -94,10 +95,19 @@ def main():
     if cli.args.mt:
         tracker_name_list = config.tracker_config.MULTI_TRACKER
 
+    # Load User Tags list
+    tags_list = None
+    if cli.args.buildtags:
+        try:
+            with open(USER_TAGS_PATH, "r", encoding="utf-8") as f:
+                tags_list = json.load(f)
+        except FileNotFoundError:
+            custom_console.bot_error_log(f"User tags file {USER_TAGS_PATH} not found. Please update your configuration file")
+
     # Manual upload mode
     if cli.args.upload:
         bot = Bot(path=cli.args.upload, cli=cli.args, trackers_name_list=tracker_name_list,
-                  torrent_archive_path=tracker_archive)
+                  torrent_archive_path=tracker_archive, tags_list=tags_list)
         bot.run()
 
     # Manual folder mode
@@ -108,13 +118,14 @@ def main():
             mode="folder",
             trackers_name_list=tracker_name_list,
             torrent_archive_path=tracker_archive,
+            tags_list=tags_list
         )
         bot.run()
 
     # Auto mode
     if cli.args.scan and not cli.args.ftp:
         bot = Bot(path=cli.args.scan, cli=cli.args, mode="auto", trackers_name_list=tracker_name_list,
-                  torrent_archive_path=tracker_archive)
+                  torrent_archive_path=tracker_archive, tags_list=tags_list)
         bot.run()
 
     # Watcher

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/bot.py

@@ -29,7 +29,7 @@ class Bot:
     """
 
     # Bot Manager
-    def __init__(self, path: str, cli: argparse.Namespace, trackers_name_list: list, mode="man",
+    def __init__(self, path: str, cli: argparse.Namespace, trackers_name_list: list, tags_list = None, mode="man",
                  torrent_archive_path = None):
         """
         Initializes the Bot instance with path, command-line interface object, and mode
@@ -42,6 +42,7 @@ class Bot:
         self.trackers_name_list = trackers_name_list
         self.torrent_archive_path = torrent_archive_path
         self.content_manager = None
+        self.tags_list: dict = tags_list
         self.path = path.strip()
         self.cli = cli
         self.mode = mode
@@ -101,7 +102,7 @@ class Bot:
             return False
 
         # Instance a new run
-        torrent_manager = TorrentManager(cli=self.cli, tracker_archive=self.torrent_archive_path)
+        torrent_manager = TorrentManager(cli=self.cli, tracker_archive=self.torrent_archive_path, tags_list=self.tags_list)
         # Process the torrents content (files)
         torrent_manager.process(contents=contents)
 

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/media.py

@@ -177,33 +177,6 @@ class Media:
     def igdb_id(self, value):
         self._igdb_id = value
 
-    @property
-    def generate_title(self) -> str:
-
-        if not self._generate_title:
-            # Read video and audio data from mediainfo
-            video_f = self.mediafile.video_track[0]['format']
-            audio_f = self.mediafile.audio_track[0]['format']
-            audio_lang = self.mediafile.audio_track[0]['language']
-            available_lang = ' '.join(lang for lang in self.mediafile.available_languages if lang is not None)
-
-            # Search for Season and Episode o torrent_pack
-            if 'tv' in self.category:
-                serie = f"S{str(self.guess_season).zfill(2)}" if self.guess_season else ''
-                if not self.torrent_pack:
-                    serie += f"E{str(self.guess_episode).zfill(2)}"
-            else:
-                serie = ''
-
-            # Build the title
-            self._generate_title = (f"{self.guess_title} {serie} {self.resolution} {video_f} "
-                                    f"{available_lang} {audio_f} {audio_lang.upper()}")
-        return self._generate_title
-
-    @generate_title.setter
-    def generate_title(self, value):
-        self._generate_title = value
-
     @property
     def guess_filename(self):
         if not self._guess_filename:

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/media_manager/DocuManager.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-import argparse
+from argparse import Namespace
 import os
 
 from common.bittorrent import BittorrentData
@@ -14,10 +14,10 @@ from view import custom_console
 
 class DocuManager:
 
-    def __init__(self, contents: list[Media], cli: argparse.Namespace):
+    def __init__(self, contents: list[Media], cli: Namespace):
         self._my_tmdb = None
         self.contents: list['Media'] = contents
-        self.cli: argparse = cli
+        self.cli: Namespace = cli
 
     def process(self, selected_tracker: str, tracker_name_list: list, tracker_archive: str) -> list[BittorrentData]:
 

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/media_manager/GameManager.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-import argparse
+from argparse import Namespace
 import os
 
 from common.external_services.igdb.client import IGDBClient
@@ -14,7 +14,7 @@ from view import custom_console
 
 class GameManager:
 
-    def __init__(self, contents: list["Media"], cli: argparse.Namespace):
+    def __init__(self, contents: list["Media"], cli: Namespace):
         """
         Initialize the GameManager with the given contents
 
@@ -23,7 +23,7 @@ class GameManager:
             cli (argparse.Namespace): user flag Command line
         """
         self.contents: list[Media] = contents
-        self.cli: argparse = cli
+        self.cli: Namespace = cli
         self.igdb = IGDBClient()
 
     def process(self, selected_tracker: str, tracker_name_list: list,  tracker_archive: str) -> list[BittorrentData]:

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/media_manager/TorrentManager.py

@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
 
 import argparse
-
-import requests
-
 from unit3dup.media_manager.VideoManager import VideoManager
 from unit3dup.media_manager.GameManager import GameManager
 from unit3dup.media_manager.DocuManager import DocuManager
@@ -21,10 +18,11 @@ from view import custom_console
 
 
 class TorrentManager:
-    def __init__(self, cli: argparse.Namespace, tracker_archive: str):
+    def __init__(self, cli: argparse.Namespace, tracker_archive: str, tags_list: dict):
 
         self.preferred_lang = my_language(config_settings.user_preferences.PREFERRED_LANG)
         self.tracker_archive = tracker_archive
+        self.tags_list = tags_list
         self.videos: list[Media] = []
         self.games: list[Media] = []
         self.doc: list[Media] = []
@@ -93,7 +91,7 @@ class TorrentManager:
             # Build the torrent file and upload each VIDEO to the trackers
             if self.videos:
                 video_manager = VideoManager(contents=self.videos[:self.fast_load],
-                                             cli=self.cli)
+                                             cli=self.cli, tags_list= self.tags_list)
                 video_process_results = video_manager.process(selected_tracker=selected_tracker,
                                                               tracker_name_list=trackers_name_list,
                                                               tracker_archive=self.tracker_archive)

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/media_manager/VideoManager.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-import argparse
+from argparse import Namespace
 import os
 
 from common.external_services.theMovieDB.core.api import DbOnline
@@ -18,7 +18,7 @@ from view import custom_console
 
 class VideoManager:
 
-    def __init__(self, contents: list[Media], cli: argparse.Namespace):
+    def __init__(self, contents: list[Media], cli: Namespace, tags_list: dict):
         """
         Initialize the VideoManager with the given contents
 
@@ -29,7 +29,8 @@ class VideoManager:
 
         self.torrent_found: bool = False
         self.contents: list[Media] = contents
-        self.cli: argparse.Namespace = cli
+        self.cli: Namespace = cli
+        self.tags_list: dict = tags_list
 
     def process(self, selected_tracker: str, tracker_name_list: list, tracker_archive: str) -> list[BittorrentData]:
         """
@@ -57,7 +58,8 @@ class VideoManager:
                                          episode=content.guess_episode,
                                          releaser_sign=config_settings.user_preferences.RELEASER_SIGN,
                                          tags_position=config_settings.user_preferences.TAGS_POSITION,
-                                         mediafile=content.mediafile
+                                         tags_list=self.tags_list,
+                                         mediafile=content.mediafile,
                                          )
                 content.display_name = search_tags.process()
 
@@ -91,19 +93,6 @@ class VideoManager:
                 if not db:
                     continue
 
-                # Update display name with Serie Title when requested by the user (-notitle)
-                if self.cli.notitle:
-                    # Add generated metadata to the display_title
-                    if self.cli.gentitle:
-                        content.display_name = (f"{db_online.media_result.result.get_title()} "
-                                                f"{db_online.media_result.year} ")
-                        content.display_name += " " + content.generate_title
-                    else:
-                        # otherwise keep the old meta_data and add the new display_title to it
-                        print()
-                        content.display_name = (f"{db_online.media_result.result.get_title()}"
-                                                f" {db_online.media_result.year} {content.guess_title}")
-
                 # Get meta from the media video
                 video_info = Video(media=content, tmdb_id=db.video_id, trailer_key=db.trailer_key)
                 video_info.build_info()

{unit3dup-0.9.12 → unit3dup-0.9.14}/unit3dup/upload.py

@@ -1,6 +1,6 @@
-import argparse
-import json
+from argparse import Namespace
 import requests
+import json
 
 from common.external_services.igdb.core.models.search import Game
 from common.trackers.trackers import TRACKData
@@ -15,7 +15,7 @@ from view import custom_console
 
 
 class UploadBot:
-    def __init__(self, content: Media, tracker_name: str, cli: argparse.ArgumentParser):
+    def __init__(self, content: Media, tracker_name: str, cli: Namespace):
         self.cli = cli
         self.content = content
         self.tracker_name = tracker_name