ittup 1.2.1__tar.gz → 1.2.3__tar.gz

{ittup-1.2.1 → ittup-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ittup
-Version: 1.2.1
+Version: 1.2.3
 Summary: ItaTorrents uploader
 Author: Parzival, TehMaat
 License-Expression: MIT
@@ -68,7 +68,7 @@ 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
-- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``, ``video_encoder``
+- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``
 
 
 ITTup can grab the first page, convert it to an image (using xpdf),

{ittup-1.2.1 → ittup-1.2.3}/README.rst

@@ -35,7 +35,7 @@ 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
-- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``, ``video_encoder``
+- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``
 
 
 ITTup can grab the first page, convert it to an image (using xpdf),

{ittup-1.2.1 → ittup-1.2.3}/ittup/common/settings.py

@@ -625,13 +625,11 @@ class Load:
                 "NUMBER_OF_SCREENSHOTS": 4,
                 "TAGS_POSITION_MOVIE": ["title", "year", "part", "version", "resolution", "uhd", "platform", "source",
                                         "remux",
-                                        "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec",
-                                        "video_encoder"],
+                                        "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec"],
 
                 "TAGS_POSITION_SERIE": ["title", "season", "version", "resolution", "uhd", "platform", "source",
                                         "remux",
-                                        "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec",
-                                        "video_encoder"],
+                                        "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec"],
 
                 "YOUTUBE_PREF_LANG": "IT",
                 "DUPLICATE_ON": "true",
@@ -662,7 +660,7 @@ class Load:
                 "MY_TEXT_1": "",
                 "MY_TEXT_2": "",
                 "MY_TEXT_3": "",
-                "MY_TEXT_H": "[center]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/center]"
+                "MY_TEXT_H": ""
             },
             "options": {
                 "FTPX_USER": "user",

{ittup-1.2.1 → ittup-1.2.3}/ittup/common/tags.py

@@ -46,18 +46,28 @@ audio_translate = {
     "MPEG Audio": "MPEG",
 }
 
-video_translate = {
-    "AVC": "H.264",
-    "HEVC": "H.265",
-    "H265": "H.265",
-    "H264": "H.264",
+# Codec family from the MediaInfo 'format' of the video track
+video_family = {
+    "AVC": "264",
+    "HEVC": "265",
 }
 
-video_encoder_translate = {
-    "X265": "x.265",
-    "X264": "x.264",
+# Release type from the source/remux tags of the file name. Each tag is mapped on its own:
+# DLMUX is in the "remux" category but it is a WEB-DL
+UNTOUCHED_TAGS = {"REMUX", "BDREMUX", "BDMUX", "VU", "UNTOUCHED", "DVDMUX", "FULL DISC"}
+WEB_TAGS = {"WEB-DL", "WEB", "WEBDL", "WEB-DLMUX", "WEBDLMUX", "WEB-MUX", "WEBMUX", "DLMUX", "HDTV"}
+ENCODE_TAGS = {"ENCODE", "WEBRIP", "BDRIP", "BRRIP", "DVDRIP", "UHDRIP", "FHDRIP", "WEB-DLRIP", "WEBDLRIP"}
+
+# How each release type writes the 264/265 codec
+video_codec_labels = {
+    "untouched": {"264": "AVC", "265": "HEVC"},
+    "web": {"264": "H.264", "265": "H.265"},
+    "encode": {"264": "x264", "265": "x265"},
 }
 
+# x264, x.264, H264, H.265, AVC, HEVC... in the file name
+NAME_CODEC_PATTERN = re.compile(r'(?<![a-z0-9])(?:[xh][._ -]?26([45])|(avc)|(hevc))(?![a-z0-9])', re.IGNORECASE)
+
 TAG_NORMALIZE = {
     "BLURAY": "BluRay",
     "BLU-RAY": "BluRay",
@@ -85,6 +95,8 @@ class SearchTags(object):
         self.title = title
         self.year = year
         self.tags_dict = {}
+        self.release_type: str | None = None
+        self.name_family: str | None = None
 
         self.TAG_TYPES: dict = tags_list
         self.SIGNS_LIST: dict = sign_list
@@ -187,6 +199,14 @@ class SearchTags(object):
         if self.tags_dict.get("source", None):
             self.tags_dict["source"] = list(dict.fromkeys(self.tags_dict["source"]))
 
+        # x264/x265 from the file name only tell the codec family: the codec is written by vcodec
+        name_encoders = self.tags_dict.pop('video_encoder', [])
+        self.name_family = self.codec_family_from_name(self.filename, name_encoders)
+        # Read the release type before 'remux' gets the REMUX tag appended below
+        self.release_type = self.detect_release_type(
+            self.tags_dict.get('source', []) + self.tags_dict.get('remux', [])
+        )
+
         if norm:
             # Skip if it is part of title es: "Wicked.Parte.2.2025.iTA" Title = Wicked Parte 2
             if not any(t in self.title.lower() for t in ['part', 'parte']):
@@ -208,10 +228,6 @@ 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)
                 if not updated_category:
@@ -297,16 +313,103 @@ class SearchTags(object):
             audio_codecs.extend(languages)
         return {category: audio_codecs}
 
+    @staticmethod
+    def detect_release_type(tags: list) -> str | None:
+        """
+        Release type from the source/remux tags: 'encode', 'untouched', 'web' or None when uncertain
+        (es. BLURAY alone or no tags)
+        """
+        tags = {str(tag).upper() for tag in tags}
+        if tags & ENCODE_TAGS:
+            return "encode"
+        if tags & UNTOUCHED_TAGS:
+            return "untouched"
+        if tags & WEB_TAGS:
+            return "web"
+        return None
+
+    @staticmethod
+    def codec_family_from_name(filename: str, name_encoders: list) -> str | None:
+        """
+        Codec family ('264' or '265') written in the file name, None if missing or ambiguous
+        """
+        families = {str(tag)[-3:] for tag in name_encoders}
+        for match in NAME_CODEC_PATTERN.finditer(filename):
+            if match.group(1):
+                families.add(f"26{match.group(1)}")
+            elif match.group(2):
+                families.add("264")
+            else:
+                families.add("265")
+        families &= {"264", "265"}
+        return families.pop() if len(families) == 1 else None
+
+    @staticmethod
+    def encoder_signature(video: dict) -> str | None:
+        """
+        x264/x265 signature left by the encoder in the video track ('264', '265' or None)
+        """
+        library = str(video.get('writing_library') or '').lower()
+        for family in ("264", "265"):
+            if f"x{family}" in library:
+                return family
+        settings = str(video.get('encoding_settings') or '').lower()
+        if "cabac=" in settings:
+            return "264"
+        if "cpuid=" in settings or "ctu=" in settings:
+            return "265"
+        return None
+
+    @staticmethod
+    def normalize_other_codec(video: dict, filename: str) -> str:
+        """
+        Codecs other than 264/265 (AV1, VP9, VC-1, MPEG-2, XviD...)
+        """
+        video_format = str(video.get('format') or '')
+        if video_format == "MPEG Video":
+            version = re.search(r'\d', str(video.get('format_version') or ''))
+            return f"MPEG-{version.group(0)}" if version else "MPEG"
+        if video_format == "MPEG-4 Visual":
+            hint = f"{video.get('codec_id') or ''} {video.get('writing_library') or ''} {filename}".upper()
+            if "XVID" in hint:
+                return "XviD"
+            if "DIVX" in hint or "DX50" in hint:
+                return "DivX"
+            return "MPEG-4"
+        return video_format
+
     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
+        video = self.mediafile.video_track[0] if self.mediafile.video_track else {}
+        video_format = str(video.get('format') or '')
+        mediainfo_family = video_family.get(video_format)
+
+        # The file name tells the family, MediaInfo wins when they don't agree
+        family = self.name_family
+        if video_format:
+            if self.name_family and self.name_family != mediainfo_family:
+                custom_console.bot_warning_log(
+                    f"<> Video codec warning: the file name says {self.name_family} but MediaInfo says"
+                    f" '{video_format}'. Using MediaInfo")
+            family = mediainfo_family
+
+        if not family:
+            if video_format:
+                return {category: self.normalize_other_codec(video, self.filename)}
+            return {}
+
+        # The encoder in MediaInfo is only a check: it is never read on a WEB-DL
+        if self.release_type == "untouched":
+            if self.encoder_signature(video):
+                custom_console.bot_warning_log(
+                    f"<> Warning: possible fake REMUX, the video track was encoded with"
+                    f" '{video.get('writing_library') or 'x' + family}'")
+            label = "untouched"
+        elif self.release_type in ("encode", "web"):
+            label = self.release_type
+        else:
+            label = "encode" if self.encoder_signature(video) else "web"
 
+        return {category: video_codec_labels[label][family]}
 
     def mediainfo_hdr(self, category: str) -> dict:
         if self.mediafile.video_track:

{ittup-1.2.1 → ittup-1.2.3}/ittup/core/bot.py

@@ -198,11 +198,10 @@ class Bot:
 
                 # Start uploading only the new files, one at a time
                 print()
-                self.run(include_paths=moved_paths)
-                print()
-                announce_idle = True
                 for moved_path in moved_paths:
                     self._run_isolated(include_path=moved_path, timeout=timeout)
+                print()
+                announce_idle = True
 
         except KeyboardInterrupt:
             custom_console.bot_log("Exiting...")
@@ -216,8 +215,15 @@ class Bot:
         Returns:
             True if the child process ended without errors
         """
+        # The child must be a fork of the watcher: it shares the loaded config and the console (the questions
+        # are answered on stdin), and the Bot can't be pickled for 'spawn' or 'forkserver' (the default
+        # since Python 3.14). Where fork isn't available or safe (Windows, macOS) the entry runs in the watcher
+        if "fork" not in multiprocessing.get_all_start_methods() or sys.platform == "darwin":
+            return self.run(include_paths=[include_path])
+
         name = os.path.basename(include_path)
-        process = multiprocessing.Process(target=_run_worker, args=(self, include_path), daemon=True)
+        process = multiprocessing.get_context("fork").Process(target=_run_worker, args=(self, include_path),
+                                                              daemon=True)
         process.start()
         try:
             process.join(timeout if timeout > 0 else None)

{ittup-1.2.1 → ittup-1.2.3}/ittup/core/media_manager/DocuManager.py

@@ -38,14 +38,14 @@ class DocuManager:
                 custom_console.bot_log(f"Watcher Active.. skip the old upload '{content.file_name}'")
                 continue
 
-            torrent_response = UserContent.torrent(content=content, tracker_name_list=tracker_name_list,
-                                                   selected_tracker=selected_tracker, this_path=torrent_filepath)
-
-            # Skip if it is a duplicate
+            # Skip if it is a duplicate, before hashing the files
             if ((self.cli.duplicate or config_settings.user_preferences.DUPLICATE_ON)
                     and UserContent.is_duplicate(content=content, tracker_name=selected_tracker, cli=self.cli)):
                 continue
 
+            torrent_response = UserContent.torrent(content=content, tracker_name_list=tracker_name_list,
+                                                   selected_tracker=selected_tracker, this_path=torrent_filepath)
+
             # print the title will be shown on the torrent page
             custom_console.bot_log(f"'DISPLAYNAME'...{{{content.display_name}}}\n")
 

{ittup-1.2.1 → ittup-1.2.3}/ittup/core/media_manager/GameManager.py

@@ -61,15 +61,14 @@ class GameManager:
                 custom_console.bot_log(f"Watcher Active.. skip the old upload '{content.file_name}'")
                 continue
 
-            torrent_response = UserContent.torrent(content=content, tracker_name_list=tracker_name_list,
-                                                       selected_tracker=selected_tracker, this_path=torrent_filepath)
-
-
-            # Skip if it is a duplicate
+            # Skip if it is a duplicate, before hashing the files
             if ((self.cli.duplicate or config_settings.user_preferences.DUPLICATE_ON)
                     and UserContent.is_duplicate(content=content, tracker_name=selected_tracker, cli=self.cli)):
                 continue
 
+            torrent_response = UserContent.torrent(content=content, tracker_name_list=tracker_name_list,
+                                                       selected_tracker=selected_tracker, this_path=torrent_filepath)
+
             # Login to IGDB only when the first game needs it
             if not self.igdb_logged:
                 if not self.igdb.connect():

{ittup-1.2.1 → ittup-1.2.3}/ittup/core/media_manager/VideoManager.py

@@ -83,15 +83,16 @@ class VideoManager:
             # Filter contents based on the preferred language or duplicates
             if UserContent.is_preferred_language(content=content):
 
-                torrent_response = UserContent.torrent(content=content, tracker_name_list=tracker_name_list,
-                                                       selected_tracker=selected_tracker, this_path=torrent_filepath)
-
                 # Skip(S) if it is a duplicate or let the user choose to continue (C)
+                # Checked before hashing so a skipped duplicate doesn't cost a torrent file
                 if ((self.cli.duplicate or config_settings.user_preferences.DUPLICATE_ON)
                         and UserContent.is_duplicate(content=content, tracker_name=selected_tracker,
                                                      cli=self.cli)):
                     continue
 
+                torrent_response = UserContent.torrent(content=content, tracker_name_list=tracker_name_list,
+                                                       selected_tracker=selected_tracker, this_path=torrent_filepath)
+
                 # Search for VIDEO ID
                 db_online = DbOnline(media=content, category=content.category, no_title=self.cli.notitle)
                 db = db_online.media_result

{ittup-1.2.1 → ittup-1.2.3}/ittup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ittup
-Version: 1.2.1
+Version: 1.2.3
 Summary: ItaTorrents uploader
 Author: Parzival, TehMaat
 License-Expression: MIT
@@ -68,7 +68,7 @@ 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
-- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``, ``video_encoder``
+- Generate various tags for titles: ``version``, ``resolution``, ``uhd``, ``platform``, ``source``, ``remux``, ``multi``, ``acodec``, ``channels``, ``flag``, ``subtitle``, ``vcodec``, ``hdr``
 
 
 ITTup can grab the first page, convert it to an image (using xpdf),

{ittup-1.2.1 → ittup-1.2.3}/ittup.egg-info/SOURCES.txt

@@ -102,4 +102,5 @@ ittup/core/media_manager/VideoManager.py
 ittup/core/media_manager/__init__.py
 ittup/core/media_manager/common.py
 ittup/view/__init__.py
-ittup/view/custom_console.py
+ittup/view/custom_console.py
+tests/test_vcodec.py

{ittup-1.2.1 → ittup-1.2.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 dynamic = ["dependencies"]
 name = "ittup"
-version = "1.2.1"
+version = "1.2.3"
 description = "ItaTorrents uploader"
 readme = "README.rst"
 requires-python = ">=3.10"

ittup-1.2.3/tests/test_vcodec.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+from types import SimpleNamespace
+
+import pytest
+
+from ittup.common import tags
+from ittup.common.settings import Validate
+from ittup.common.tags import SearchTags
+from ittup.common.trackers.tags_list import TAGS_LIST
+
+TAGS_POSITION = ["title", "year", "part", "version", "resolution", "uhd", "platform", "source", "remux",
+                 "multi", "acodec", "channels", "flag", "subtitle", "hdr", "vcodec"]
+
+X264_LIBRARY = "x264 core 164 r3095 baee400"
+X265_LIBRARY = "x265 3.5+1-f0c1022b6:[Linux][GCC 9.3.0][64 bit] 10bit"
+
+
+@pytest.fixture
+def warnings(monkeypatch):
+    logged = []
+    monkeypatch.setattr(tags.custom_console, "bot_warning_log", logged.append)
+    return logged
+
+
+def build_title(filename: str, video_format: str | None, writing_library: str = "",
+                encoding_settings: str = "", tags_position: list | None = None,
+                **video_fields) -> tuple[str, dict]:
+    video_track = []
+    if video_format:
+        video_track.append({"format": video_format, "writing_library": writing_library,
+                            "encoding_settings": encoding_settings, **video_fields})
+    mediafile = SimpleNamespace(video_track=video_track, audio_track=[], subtitle_track=[])
+    media = SimpleNamespace(mediafile=mediafile, torrent_pack=False, resolution="1080p", pack=None)
+    search = SearchTags(filename=filename, title="Movie", year="2020", season=None, episode=None, media=media,
+                        tags_position=list(tags_position or TAGS_POSITION), tags_list=TAGS_LIST, sign_list={},
+                        ban_list={"dummy": "banned"}, releaser_sign="")
+    return search.process()
+
+
+def vcodec(filename: str, video_format: str | None, **kwargs) -> str | None:
+    _, tags_dict = build_title(filename, video_format, **kwargs)
+    return tags_dict.get("vcodec")
+
+
+def test_remux_hevc(warnings):
+    assert vcodec("Movie.2020.2160p.BluRay.REMUX.HEVC.TrueHD.7.1-GRP.mkv", "HEVC") == "HEVC"
+    assert not warnings
+
+
+def test_remux_with_x265_signature_warns(warnings):
+    codec = vcodec("Movie.2020.2160p.BluRay.REMUX.HEVC-GRP.mkv", "HEVC", writing_library=X265_LIBRARY)
+    assert codec == "HEVC"
+    assert any("fake REMUX" in message for message in warnings)
+
+
+def test_web_dl_avc_with_x264_signature(warnings):
+    codec = vcodec("Movie.2020.1080p.AMZN.WEB-DL.DDP5.1.H.264-GRP.mkv", "AVC", writing_library=X264_LIBRARY)
+    assert codec == "H.264"
+    assert not warnings
+
+
+def test_dlmux_is_web_dl():
+    assert vcodec("Movie.2020.1080p.DLMux.ITA.ENG.AC3-GRP.mkv", "AVC", writing_library=X264_LIBRARY) == "H.264"
+
+
+def test_webrip_x265():
+    assert vcodec("Movie.2020.1080p.WEBRip.x265-GRP.mkv", "HEVC") == "x265"
+
+
+def test_encode_x265_is_not_doubled(warnings):
+    title, tags_dict = build_title("Movie.2020.1080p.BDRip.x265.10bit-GRP.mkv", "HEVC",
+                                   writing_library=X265_LIBRARY)
+    assert tags_dict["vcodec"] == "x265"
+    assert "video_encoder" not in tags_dict
+    assert "H.265" not in title
+    assert title.count("x265") == 1
+    assert not warnings
+
+
+def test_bluray_alone_with_x264_signature():
+    assert vcodec("Movie.2020.1080p.BluRay.DTS-GRP.mkv", "AVC", writing_library=X264_LIBRARY) == "x264"
+
+
+def test_bluray_alone_without_signature():
+    assert vcodec("Movie.2020.1080p.BluRay.DTS-GRP.mkv", "AVC") == "H.264"
+
+
+def test_no_release_type_no_signature():
+    assert vcodec("Movie.2020.1080p.ITA.ENG-GRP.mkv", "AVC") == "H.264"
+
+
+def test_signature_from_encoding_settings():
+    settings = "cabac=1 / ref=4 / deblock=1:-3:-3 / analyse=0x3:0x133"
+    assert vcodec("Movie.2020.1080p.ITA-GRP.mkv", "AVC", encoding_settings=settings) == "x264"
+
+
+def test_name_and_mediainfo_disagree(warnings):
+    codec = vcodec("Movie.2020.1080p.BDRip.x264-GRP.mkv", "HEVC", writing_library=X265_LIBRARY)
+    assert codec == "x265"
+    assert any("MediaInfo" in message for message in warnings)
+
+
+def test_family_from_name_without_mediainfo():
+    assert vcodec("Movie.2020.1080p.WEBRip.x264-GRP.mkv", None) == "x264"
+    assert vcodec("Movie.2020.1080p.BluRay.REMUX.AVC-GRP.mkv", None) == "AVC"
+
+
+@pytest.mark.parametrize("video_format, video_fields, expected", [
+    ("AV1", {}, "AV1"),
+    ("VP9", {}, "VP9"),
+    ("VC-1", {}, "VC-1"),
+    ("MPEG Video", {"format_version": "Version 2"}, "MPEG-2"),
+    ("MPEG-4 Visual", {"codec_id": "XVID"}, "XviD"),
+])
+def test_other_codecs(warnings, video_format, video_fields, expected):
+    # The release type rules don't apply to codecs other than 264/265
+    assert vcodec("Movie.2020.1080p.BluRay.REMUX-GRP.mkv", video_format, **video_fields) == expected
+    assert vcodec("Movie.2020.1080p.WEBRip-GRP.mkv", video_format, writing_library=X264_LIBRARY,
+                  **video_fields) == expected
+    assert not warnings
+
+
+def test_video_encoder_in_tags_position():
+    position = TAGS_POSITION + ["video_encoder"]
+    assert Validate.validate_tags_position(position) == position
+
+    title, tags_dict = build_title("Movie.2020.1080p.WEBRip.x265-GRP.mkv", "HEVC", tags_position=position)
+    assert "video_encoder" not in tags_dict
+    assert title.lower().count("265") == 1