Unit3Dup 0.9.9__tar.gz → 0.9.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.9
+Version: 0.9.11
 Summary: An uploader for the Unit3D torrent tracker
 Author: Parzival
 License-Expression: MIT

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.9
+Version: 0.9.11
 Summary: An uploader for the Unit3D torrent tracker
 Author: Parzival
 License-Expression: MIT

{unit3dup-0.9.9 → unit3dup-0.9.11}/common/p2p_tags.py

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
 import os
 import re
+from collections import deque
 from common.utility import ManageTitles
 from common.mediainfo import MediaFile
-from collections import deque
 
 TAG_TYPES = {
     "WEB-DL": "source",
@@ -16,8 +16,10 @@ TAG_TYPES = {
     "REMUX": "source",
     "VU": "source",
     "UHD": "source",
+    "UHDRIP": "source",
     "BLURAY": "source",
 
+    "ATVP": "platform",
     "AMZN": "platform",
     "AMC": "platform",
     "CN": "platform",
@@ -53,8 +55,6 @@ TAG_TYPES = {
     "STZ": "platform",
     "TIMV": "platform",
 
-    "SUB": "subtitle",
-    "SUBS": "subtitle",
     "ITA": "flag",
     "ENG": "flag",
     "FRA": "flag",
@@ -65,6 +65,9 @@ TAG_TYPES = {
     "POR": "flag",
     "PRT": "flag",
 
+    "SUB": "subtitle",
+    "SUBS": "subtitle",
+
     "ATMOS": "audio",
     "TRUEHD": "audio",
     "DTSHD": "audio",
@@ -74,19 +77,19 @@ TAG_TYPES = {
     "DDP5.1": "audio",
     "DDP2.0": "audio",
     "DTS": "audio",
-
+    "XLL": "audio",
     "DD7.1": "audio",
     "DD5.1": "audio",
     "DD2.0": "audio",
-
     "DD+ 7.1": "audio",
     "DD+ 5.1": "audio",
     "DD+ 2.0": "audio",
-
+    "DTS-HD MA 7.1": "audio",
+    "DTS-HD MA 5.1": "audio",
+    "DTS-HD MA 2.0": "audio",
     "DD 7.1": "audio",
     "DD 5.1": "audio",
     "DD 2.0": "audio",
-
     "AAC2.0": "audio",
     "AAC5.1": "audio",
     "AC3": "audio",
@@ -94,22 +97,25 @@ TAG_TYPES = {
     "DD+": "audio",
     "DDP": "audio",
     "E-AC3": "audio",
+    "E-AC-3": "audio",
     "EAC3": "audio",
     "AC-3": "audio",
     "AAC": "audio",
+    "AAC LC": "audio",
     "AVC": "audio",
 
     "7.1": "channels",
     "5.1": "channels",
     "2.0": "channels",
 
+    "X.264": "video_encoder",
+    "X264": "video_encoder",
+    "X.265": "video_encoder",
+    "X265": "video_encoder",
+
     "H.264": "video",
-    "X.264": "video",
-    "X264": "video",
-    "H264": "video",
     "H.265": "video",
-    "X.265": "video",
-    "X265": "video",
+    "H264": "video",
     "H265": "video",
     "HEVC": "video",
     "DV": "video",
@@ -121,7 +127,6 @@ TAG_TYPES = {
     "HDR": "video",
     "HDR10+": "video",
     "FHDRIP": "video",
-    "UHDRIP": "video",
     "FULL HD": "video",
     "FULLHD": "video",
     "HD": "video",
@@ -136,14 +141,15 @@ TAG_TYPES = {
     "720P": "resolution",
     "576P": "resolution",
     "480P": "resolution",
-
 }
 
 
 class P2pTags:
-    def __init__(self, filename: str, title: str, year: str, mediafile_resolution: str, season: int, episode: int,
-                 episode_title: str, releaser_sign: str, tags_position: list, mediafile: MediaFile):
-
+    def __init__(
+            self, filename: str, title: str, year: str, mediafile_resolution: str,
+            season: int, episode: int, episode_title: str, releaser_sign: str,
+            tags_position: list, mediafile: MediaFile
+    ):
         self.filename = filename
         self.title = title
         self.year = year
@@ -156,55 +162,65 @@ class P2pTags:
         self.tags_position = tags_position
         self.sign_in_title: str | None = None
 
+        self.tags_sorted = self._extract_tags()
+
+    def _extract_tags(self) -> list:
         search_tags = sorted(TAG_TYPES.keys(), key=len, reverse=True)
-        pattern = re.compile(
-            r'\b(?:' + '|'.join(map(re.escape, search_tags)) + r')\b',
-            re.IGNORECASE
-        )
+        pattern = re.compile(r'\b(?:' + '|'.join(map(re.escape, search_tags)) + r')\b', re.IGNORECASE)
 
         # Search for tags in the title
-        tags_match = pattern.findall(filename.upper())
-        # remove dope
-        tags_match = list(dict.fromkeys(tags_match))
-
+        tags_match = list(dict.fromkeys(pattern.findall(self.filename)))
         # Search for channels
-        channel_s = self.mediafile.audio_track[0].get('channel_s', None)
-        ch: str = ''
-        # map channels
-        if channel_s == 6:
-            ch = "5.1"
-        elif channel_s == 8:
-            ch = "7.1"
-        elif channel_s == 2:
-            ch = "2.0"
-
-        # extract categories results
-        categories = [TAG_TYPES.get(tag) for tag in tags_match]
+        ch = ''
+        if self.mediafile.audio_track:
+            channel_s = self.mediafile.audio_track[0].get('channel_s', 0)
+            ch = {2: "2.0", 6: "5.1", 8: "7.1"}.get(channel_s, "")
 
+        # Categories of found tags
+        categories = [TAG_TYPES.get(tag.upper()) for tag in tags_match]
         # Add video codec only if there is no video categories
-        if 'video' not in categories:
-            video_codec = self.mediafile.video_track[0].get('format', "") if self.mediafile.video_track else ""
-            tags_match.append(video_codec)
-
-        # Add audio codec only if there is no audio categories
-        if 'audio' not in categories:
-            audio_format = self.mediafile.audio_track[0].get('format', "") if self.mediafile.audio_track else ""
-            tags_match.append(audio_format)
+        if 'video' not in categories and self.mediafile.video_track:
+            video_codec = self.mediafile.video_track[0].get('format', "")
+            if video_codec:
+                tags_match.append(video_codec)
+
+        # Add audio codec only if there is no video categories
+        if 'audio' not in categories and self.mediafile.audio_track:
+            for audio in self.mediafile.audio_track:
+                # Other_format https://github.com/sbraz/pymediainfo/discussions/119#discussioncomment-2330673
+                # con format mi restituisce solo DTS
+                # Use other_format per format che hanno uno o piu tag
+                other_format = audio.get('other_format', [])
+                if other_format:
+                    tags_match.append(other_format[0])
 
         # Add tag language if there is no tag
         flags = self._audio_lang()
-        # are all the language tags from mediaInfo available in the title?
-        if len(flags) != tags_match.count('flag'):
-            missing_flags = [tag for tag in flags if tag not in tags_match]
-            tags_match.extend(missing_flags)
+        missing_flags = [tag for tag in flags if tag not in tags_match]
+        tags_match.extend(missing_flags)
 
         # Add subtitle tag if subtitle_track exist and there is no 'sub' in the title
-        if 'subtitle' not in categories:
-            sub_tag = "SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB"
-            if self.mediafile.subtitle_track:
-                tags_match.append(sub_tag)
+        if 'subtitle' not in categories and self.mediafile.subtitle_track:
+            tags_match.append("SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB")
 
-        # Translate audio codec
+        return self._normalize_tags(tags_match, ch)
+
+    def _audio_lang(self) -> set:
+        if not self.mediafile:
+            return set()
+        langs = set()
+        for track in self.mediafile.audio_track:
+            for l in track.get('other_language', []):
+                c = ManageTitles.convert_iso(l)
+                if c:
+                    if isinstance(c, list):
+                        langs.update(c)
+                    else:
+                        langs.update(c)
+                    break
+        return langs
+
+    def _normalize_tags(self, tags_match: list, channel_tag: str) -> list:
         audio_translate = {
             "AC3": "DD",
             "AC-3": "DD",
@@ -214,139 +230,85 @@ class P2pTags:
             "DDP5.1": "DD+",
             "DDP7.1": "DD+",
             "DDP": "DD+",
+            "DTS XLL": "DTS-HD MA",
         }
 
-        # Translate video codec
         video_translate = {
-            "H.264": "x264",
-            "X.264": "x264",
-            "X264": "x264",
-            "AVC": "x264",
-            "H.265": "x265",
-            "H265": "x265",
-            "X.265": "x265",
-            "X265": "x265",
-            "HEVC": "x265",
+            "AVC": "H.264",
+            "X265": "x.265",
+            "X264": "x.264",
+            "HEVC": "H.265",
+            "H265": "H.265",
+            "H264": "H.264",
         }
 
-        # lower the res..
         resolution_lower = {"4320P", "2160P", "1080P", "720P", "576P", "480P"}
-        codec_lower = {'X.264', 'X265', 'X.265', 'X264'}
-
-        has_channel_tag = ch in tags_match
-        new_tags = []
+        codec_lower = {"X.264", "X265", "X.265", "X264"}
 
         # verify the tags found in the title
+        normalized = []
         for tag in tags_match:
             t = tag.upper()
             if t in audio_translate:
                 codec = audio_translate[t]
-                # Add channels only if it does not exist
-                if ch and not has_channel_tag:
-                    tag = f"{codec} {ch}"
-                else:
-                    tag = codec
-
+                tag = f"{codec} {channel_tag}" if channel_tag else codec
             elif t in video_translate:
                 tag = video_translate[t]
-
-            # Lower the res
-            elif t in resolution_lower:
+            elif t in resolution_lower or t in codec_lower:
                 tag = t.lower()
-
-            # Fix the 'sub' word
             elif t == "SUB":
-                sub_tag = "SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB"
-                tag = sub_tag
-
-            elif t in codec_lower:
-                tag = t.lower()
-
-            new_tags.append(tag)
-
-        tags_match = new_tags
+                tag = "SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB"
+            normalized.append(tag)
 
         # Check if a 'resolution' tag exists and add mediafile resolution if it doesn't
-        if not any(TAG_TYPES.get(tag.upper()) == "resolution" for tag in tags_match):
-            tags_match.append(self.mediafile_resolution)
+        if not any(TAG_TYPES.get(tag.upper()) == "resolution" for tag in normalized):
+            normalized.append(self.mediafile_resolution)
 
+        # Sort and alternate audio/flag tags
+        return self._sort_tags(normalized, channel_tag)
+
+    def _sort_tags(self, tags: list, channel_tag: str) -> list:
         # /// Sort tags based on 2 rules:
         # 1) Order by tag_positions
         # 2) For audio and flag categories alternate them (audio/flag/audio/flag)
         # We can't sort each tags so we create dedicated list
-        audio_q = deque()
-        flag_q = deque()
-        channel_q = deque()
-
-        # This dict is for other categories
+        audio_q, flag_q, channel_q = deque(), deque(), deque()
         other_groups = {}
 
-        # Isolate audio and flag tags
-        # All other tags will follow the normal precedence order
-        for tag in tags_match:
+        for tag in tags:
             cat = TAG_TYPES.get(tag.upper(), "unknown")
             if cat == "audio":
-                # Add audio tag to its queue
-                audio_q.append(tag)
+                audio_q.append(tag.upper())
             elif cat == "channels":
                 channel_q.append(tag)
             elif cat == "flag":
-                # Add flag tag to its queue
-                flag_q.append(tag)
+                flag_q.append(tag.upper())
+            elif cat == "video":
+                other_groups.setdefault(cat, []).append(tag.upper())
+            elif cat == "video_encoder":
+                # Skip video encoder
+                continue
             else:
-                # Add the other tags to other_groups
                 other_groups.setdefault(cat, []).append(tag)
 
         # Alternate only if we have at least 2 audio and 2 flag tags
+        mixed = []
         if len(audio_q) >= 2 and len(flag_q) >= 2:
-            mixed_audio_ch_flag = []
-            # Alternate
             while audio_q or flag_q:
-                if audio_q:
-                    # get the first left audio and append to new list
-                    mixed_audio_ch_flag.append(audio_q.popleft())
-                if channel_q:
-                    mixed_audio_ch_flag.append(channel_q.popleft())
-                if flag_q:
-                    # get the first right flag and append to new list
-                    mixed_audio_ch_flag.append(flag_q.popleft())
+                if audio_q: mixed.append(audio_q.popleft())
+                if channel_q: mixed.append(channel_q.popleft())
+                if flag_q: mixed.append(flag_q.popleft())
         else:
-            # otherwise goes for normal precedence
-            mixed_audio_ch_flag = list(audio_q) + list(channel_q) + list(flag_q)
+            mixed = list(audio_q) + list(channel_q) + list(flag_q)
 
-        # Rebuild the title ordering each tag+ audio/flag by tag_position
         result = []
-
         for cat in self.tags_position:
-            if cat in ("audio", "channels", "flag"):
-                # Insert the audio/flag processed tags
-                if mixed_audio_ch_flag:
-                    result.extend(mixed_audio_ch_flag)
-                    # clear
-                    mixed_audio_ch_flag = []
+            if cat in ("audio", "channels", "flag") and mixed:
+                result.extend(mixed)
+                mixed = []
             elif cat in other_groups:
                 result.extend(other_groups[cat])
-        self.tags_sorted = result
-
-    def _audio_lang(self) -> list:
-
-        if not self.mediafile:
-            return []
-
-        lang: list = []
-        for track in self.mediafile.audio_track:
-            l = track.get('other_language', None)
-            if l:
-                for t in l:
-                    c = ManageTitles.convert_iso(t)
-                    if c:
-                        if isinstance(c, list):
-                            lang.extend(c)
-                            break
-                        else:
-                            lang.append(c)
-                            break
-        return lang
+        return result
 
     def process(self) -> str:
         se_str = ''
@@ -357,21 +319,14 @@ class P2pTags:
         elif self.episode is not None:
             se_str = f"E{self.episode:02d}"
 
+        # Detect releaser sign in filename if not provided
         if not self.releaser_sign:
-            # Search for a sign in the title
-            base_name = os.path.basename(self.filename)
-            filename, file_ext = os.path.splitext(base_name)
+            filename, _ = os.path.splitext(os.path.basename(self.filename))
             m = re.search(r'-([A-Za-z0-9]+)$', filename)
-
-            if m and m.group(1) not in TAG_TYPES:
-                self.sign_in_title = f"-{m.group(1)}"
-            else:
-                self.sign_in_title = ""
+            self.sign_in_title = f"-{m.group(1)}" if m and m.group(1) not in TAG_TYPES else ""
         else:
             self.sign_in_title = f"-{self.releaser_sign}"
 
-        parts = [self.title, str(self.year), se_str, self.episode_title]
-        filtered_parts = [part for part in parts if part]
-        title = ' '.join(filtered_parts)
-
-        return f"{title} {' '.join(self.tags_sorted)}{self.sign_in_title}"
+        parts = [self.title, str(self.year), se_str]
+        filtered_parts = [p for p in parts if p]
+        return f"{' '.join(filtered_parts)} {' '.join(self.tags_sorted)}{self.sign_in_title}"

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

@@ -15,7 +15,7 @@ from common.utility import ManageTitles
 from common import trackers
 
 config_file = "Unit3Dbot.json"
-version = "0.9.9"
+version = "0.9.11"
 
 if os.name == "nt":
     WATCHER_DESTINATION_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / "watcher_destination_path"

{unit3dup-0.9.9 → unit3dup-0.9.11}/common/utility.py

@@ -43,17 +43,33 @@ class ManageTitles:
         "ES-MX": "ESP"
     }
 
+    # From mediainfo
+    long_name = {
+        "ENGLISH": "ENG",
+        "ITALIAN": "ITA",
+        "GERMAN": "DEU",
+        "FRENCH": "FRA",
+        "SPANISH": "ESP",
+        "JAPANESE": "JPN",
+        "BRAZILIAN": "BRA",
+        "RUSSIAN": "RUS",
+        "CHINESE": "CHN",
+        "AMERICAN": "USA",
+        "BRITISH": "GBR"
+    }
     @staticmethod
     def convert_iso(code) -> list | str | None:
         """ Convert iso 2 to 3 """
         code = code.upper()
-
         # if it's 'multilang'
         if '-' in code:
             codes = code.split('-')
         else:
             codes = [code]
 
+        if code in ManageTitles.long_name:
+            codes = [ManageTitles.long_name[code]]
+
         result = []
         for part in codes:
             # Capture the 2 or 3 letter code followed by '-' or end string
@@ -167,45 +183,45 @@ class ManageTitles:
         filename_sanitized = re.sub(r"v\d+(?:[ .]\d+)*", "", filename_sanitized).strip()
 
         # Remove dots, extra spaces
-        filename_sanitized = re.sub(r"[._]", " ", filename_sanitized)
+        # filename_sanitized = re.sub(r"[._]", " ", filename_sanitized)
 
         # remove spaces, tab, newline
         filename_sanitized = re.sub(r"\s+", " ", filename_sanitized)
 
         # Recover tag
-        filename_sanitized = ManageTitles.recover_tag(filename_sanitized)
+        # filename_sanitized = ManageTitles.recover_tag(filename_sanitized)
 
         # remove double space
         filename_sanitized = re.sub(r"\s+", " ", filename_sanitized).strip()
 
         return filename_sanitized
 
-    @staticmethod
-    def recover_tag(filename_sanitized: str) -> str:
-
-        # Add the tag
-        replacements = [
-            (r'\b7 \b1\b', '7.1'),
-            (r'\b5 \b1\b', '5.1'),
-            (r'\bDDP5 \b1\b', 'DDP5.1'),
-            (r'\bDDP2 \b0\b', 'DDP2.0'),
-            (r'\bDD5 \b1\b', 'DD5.1'),
-            (r'\bDD2 \b0\b', 'DD2.0'),
-            (r'\b2 \b0\b', '2.0'),
-            (r'\bWEB \bDL\b', 'WEB-DL'),
-            (r'\bWEB \bDLMUX\b', 'WEB-DLMUX'),
-            (r'\bBD \bUNTOUCHED\b', 'BD-UNTOUCHED'),
-            (r'\bCINEMA \bMD\b', 'CINEMA-MD'),
-            (r'\bHEVC \bFHC\b', 'HEVC-FHC'),
-            (r'\bCBR \bCBZ\b', 'CBR-CBZ'),
-            (r'\bH \b264\b', 'H.264'),
-            (r'\bH \b265\b', 'H.265'),
-            (r'\bAAC2 \b0\b', 'AAC2.0'),
-        ]
-
-        for tag, replacement in replacements:
-            filename_sanitized = re.sub(tag, replacement, filename_sanitized, flags=re.IGNORECASE)
-        return filename_sanitized
+    # @staticmethod
+    # def recover_tag(filename_sanitized: str) -> str:
+    #
+    #     # Add the tag
+    #     replacements = [
+    #         (r'\b7 \b1\b', '7.1'),
+    #         (r'\b5 \b1\b', '5.1'),
+    #         (r'\bDDP5 \b1\b', 'DDP5.1'),
+    #         (r'\bDDP2 \b0\b', 'DDP2.0'),
+    #         (r'\bDD5 \b1\b', 'DD5.1'),
+    #         (r'\bDD2 \b0\b', 'DD2.0'),
+    #         (r'\b2 \b0\b', '2.0'),
+    #         (r'\bWEB \bDL\b', 'WEB-DL'),
+    #         (r'\bWEB \bDLMUX\b', 'WEB-DLMUX'),
+    #         (r'\bBD \bUNTOUCHED\b', 'BD-UNTOUCHED'),
+    #         (r'\bCINEMA \bMD\b', 'CINEMA-MD'),
+    #         (r'\bHEVC \bFHC\b', 'HEVC-FHC'),
+    #         (r'\bCBR \bCBZ\b', 'CBR-CBZ'),
+    #         (r'\bH \b264\b', 'H.264'),
+    #         (r'\bH \b265\b', 'H.265'),
+    #         (r'\bAAC2 \b0\b', 'AAC2.0'),
+    #     ]
+    #
+    #     for tag, replacement in replacements:
+    #         filename_sanitized = re.sub(tag, replacement, filename_sanitized, flags=re.IGNORECASE)
+    #     return filename_sanitized
 
 
 class MyString:

{unit3dup-0.9.9 → unit3dup-0.9.11}/pyproject.toml

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