ittup 1.2.2__tar.gz → 1.3.0__tar.gz

{ittup-1.2.2 → ittup-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ittup
-Version: 1.2.2
+Version: 1.3.0
 Summary: ItaTorrents uploader
 Author: Parzival, TehMaat
 License-Expression: MIT

{ittup-1.2.2 → ittup-1.3.0}/ittup/common/external_services/mediaresult.py

@@ -4,8 +4,9 @@ from datetime import datetime
 
 class MediaResult:
     def __init__(self, result=None, video_id: int = 0, imdb_id = None, tvdb_id = None, trailer_key: str = None,
-                 keywords_list: str = None, season_title = None):
+                 keywords_list: str = None, season_title = None, original_language: str = None):
         self.result = result
+        self._original_language = original_language
         self.trailer_key = trailer_key
         self.keywords_list = keywords_list
         self.video_id = video_id
@@ -20,6 +21,9 @@ class MediaResult:
             except ValueError:
                 pass
 
-
-
-
+    @property
+    def original_language(self) -> str | None:
+        """ TMDB original language (ISO 639-1, es. 'en'), None when unknown """
+        # Results cached by older versions have no _original_language
+        return (getattr(self, '_original_language', None) or getattr(self.result, 'original_language', None)
+                or None)

{ittup-1.2.2 → ittup-1.3.0}/ittup/common/external_services/theMovieDB/core/api.py

@@ -235,6 +235,15 @@ class TmdbAPI(MyHttp):
                 return results[0].get('id')
         return None
 
+    def original_language(self, video_id: int, category: str) -> str | None:
+        """ Original language (ISO 639-1) of the movie or tv show """
+        if endpoint_class := self.ENDPOINTS.get(category):
+            request = {**endpoint_class.details(video_id), 'datatype': dict}
+            response = self.request(endpoint=request)
+            if response:
+                return response[0].get('original_language') or None
+        return None
+
     def external_ids(self, video_id: int, category: str) -> dict | None:
         if endpoint_class := self.ENDPOINTS.get(category):
             request = endpoint_class.external_ids(video_id)
@@ -406,7 +415,9 @@ class DbOnline(TmdbAPI):
             if not tmdb_id:
                 custom_console.bot_warning_log(f"TMDB ID not found for IMDB ID '{imdb_id}'")
 
+        original_language = None
         if tmdb_id > 0:
+            original_language = self.original_language(video_id=tmdb_id, category=self.category)
             # Fill the IDs missing from the title string
             self.add_external_ids(tmdb_id)
             # Request trailer and keywords
@@ -414,7 +425,8 @@ class DbOnline(TmdbAPI):
             keywords_list = self.keywords(tmdb_id) if trailer_key else ''
 
         search_results = MediaResult(video_id=tmdb_id, imdb_id=self.imdb_id, tvdb_id=self.tvdb_id,
-                                     trailer_key=trailer_key, keywords_list=keywords_list)
+                                     trailer_key=trailer_key, keywords_list=keywords_list,
+                                     original_language=original_language)
         self.print_results(results=search_results)
         return search_results
 

{ittup-1.2.2 → ittup-1.3.0}/ittup/common/tags.py

@@ -46,6 +46,14 @@ audio_translate = {
     "MPEG Audio": "MPEG",
 }
 
+# Audio codecs from the best to the worst: only the best ones go in the title
+audio_rank = ["TrueHD", "DTS-HD MA", "FLAC", "PCM", "DTS-ES", "DTS", "DD+", "DD", "AAC", "HE-AAC", "Opus", "MPEG"]
+# The title keeps the best ITA codec and the best codec in the original language, then fills up to
+# MAX_AUDIO_CODECS with the tracks with no language. Tracks in other languages only add their flag
+MAX_AUDIO_CODECS = 2
+# Original language (TMDB ISO 639-1) when it is not known yet
+DEFAULT_ORIGINAL_LANGUAGE = "en"
+
 # Codec family from the MediaInfo 'format' of the video track
 video_family = {
     "AVC": "264",
@@ -97,6 +105,7 @@ class SearchTags(object):
         self.tags_dict = {}
         self.release_type: str | None = None
         self.name_family: str | None = None
+        self.original_language: str = DEFAULT_ORIGINAL_LANGUAGE
 
         self.TAG_TYPES: dict = tags_list
         self.SIGNS_LIST: dict = sign_list
@@ -267,6 +276,18 @@ class SearchTags(object):
             # try to detect a known sign from SIGN_LIST
             self.releaser_sign = self.detect_releaser(self.filename, self.SIGNS_LIST)
 
+        return self.ordered_title()
+
+    def set_original_language(self, original_language: str | None) -> tuple[str, dict]:
+        """
+        Rebuild the audio tags of the title processed before with the original language from TMDB (es. 'ja')
+        """
+        self.original_language = (original_language or DEFAULT_ORIGINAL_LANGUAGE).lower()
+        if "acodec" in self.tags_position:
+            self.tags_dict.update(self.mediainfo_audio(category="acodec"))
+        return self.ordered_title()
+
+    def ordered_title(self) -> tuple[str, dict]:
         # /// Order according to tag position
         tags_dict = {
             k: self.tags_dict[k]
@@ -276,11 +297,38 @@ class SearchTags(object):
         new_title = self.build_title(tags_dict)
         return new_title, tags_dict
 
+    @staticmethod
+    def audio_language(audio: dict) -> str | None:
+        """
+        ISO alpha-3 language of an audio track, None when it is not tagged
+        """
+        for l in audio.get('other_language', []):
+            c = ManageTitles.convert_iso(l)
+            if c:
+                return c[0] if isinstance(c, list) else c
+        return None
+
+    @staticmethod
+    def audio_score(codec: str, atmos: bool, channel_s: int) -> tuple:
+        """
+        Sort key of an audio track: codec, then Atmos, then channels
+        """
+        rank = len(audio_rank) - audio_rank.index(codec) if codec in audio_rank else 0
+        return rank, atmos, channel_s
+
+    def is_original_language(self, audio: dict) -> bool:
+        codes = [str(code).lower() for code in audio.get('other_language', []) + [audio.get('language') or '']]
+        return self.original_language in codes
+
     def mediainfo_audio(self, category: str) -> dict:
         languages = []
-        audio_codecs = []
+        original_languages = []
+        # [(score, label, language, original language)]
+        tracks = []
         if self.mediafile.audio_track:
             for audio in self.mediafile.audio_track:
+                language = self.audio_language(audio)
+                original = self.is_original_language(audio)
                 other_format = audio.get('other_format', [])
                 if other_format:
                     codec_translated = audio_translate.get(other_format[0], '')
@@ -293,24 +341,32 @@ class SearchTags(object):
                     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())
+                    tracks.append((self.audio_score(codec_translated, bool(atmos), channel_s),
+                                   f"{codec_translated} {ch} {atmos}".strip(), language, original))
 
                 # 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
+                if language:
+                    languages.append(language)
+                    if original:
+                        original_languages.append(language)
                 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)
+        # Best ITA codec + best original language codec, then the tracks with no language up to MAX_AUDIO_CODECS
+        best_first = sorted(tracks, key=lambda track: track[0], reverse=True)
+        picked = [track for track in best_first if track[2] == "ITA"][:1]
+        picked += [track for track in best_first if track[3]][:1]
+        picked += [track for track in best_first if track[2] is None]
+        audio_codecs = []
+        for _, label, _, _ in picked:
+            if label not in audio_codecs and len(audio_codecs) < MAX_AUDIO_CODECS:
+                audio_codecs.append(label)
+
+        # Flags: ITA, the original language, then the other languages with no codec
+        first = [language for language in ["ITA"] + original_languages[:1] if language in languages]
+        audio_codecs.extend(dict.fromkeys(first + languages))
         return {category: audio_codecs}
 
     @staticmethod

{ittup-1.2.2 → ittup-1.3.0}/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.2 → ittup-1.3.0}/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.2 → ittup-1.3.0}/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.2 → ittup-1.3.0}/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
@@ -100,6 +101,9 @@ class VideoManager:
                 if not db:
                     continue
 
+                # The audio tags need the original language from TMDB
+                content.display_name, tags_dictionary = search_tags.set_original_language(db.original_language)
+
                 # 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()

{ittup-1.2.2 → ittup-1.3.0}/ittup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ittup
-Version: 1.2.2
+Version: 1.3.0
 Summary: ItaTorrents uploader
 Author: Parzival, TehMaat
 License-Expression: MIT

{ittup-1.2.2 → ittup-1.3.0}/ittup.egg-info/SOURCES.txt

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

{ittup-1.2.2 → ittup-1.3.0}/pyproject.toml

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

ittup-1.3.0/tests/test_acodec.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+from types import SimpleNamespace
+
+from ittup.common.tags import SearchTags
+from ittup.common.trackers.tags_list import TAGS_LIST
+
+LANGUAGES = {"ITA": ["Italian", "it", "ita"], "ENG": ["English", "en", "eng"], "FRA": ["French", "fr", "fra"],
+             "GER": ["German", "de", "deu"], "JPN": ["Japanese", "ja", "jpn"]}
+
+
+def track(other_format: str, channel_s: int, language: str | None = None, commercial_name: str = "") -> dict:
+    return {"other_format": [other_format], "channel_s": channel_s, "commercial_name": commercial_name,
+            "other_language": LANGUAGES[language] if language else []}
+
+
+def acodec(*audio_track: dict, original_language: str | None = None) -> list:
+    mediafile = SimpleNamespace(video_track=[], audio_track=list(audio_track), subtitle_track=[])
+    media = SimpleNamespace(mediafile=mediafile, torrent_pack=False, resolution="1080p", pack=None)
+    search = SearchTags(filename="Movie.2020.1080p.BluRay.REMUX-GRP.mkv", title="Movie", year="2020", season=None,
+                        episode=None, media=media, tags_position=["title", "year", "acodec"], tags_list=TAGS_LIST,
+                        sign_list={}, ban_list={"dummy": "banned"}, releaser_sign="")
+    search.process()
+    _, tags_dict = search.set_original_language(original_language)
+    return tags_dict["acodec"]
+
+
+def test_best_ita_and_best_eng():
+    assert acodec(track("MLP FBA 16-ch", 8, "ITA", "Dolby TrueHD with Dolby Atmos"), track("DTS XLL", 6, "ITA"),
+                  track("AC-3", 6, "ENG"), track("E-AC-3", 6, "ENG"), original_language="en") == [
+        "TrueHD 7.1 Atmos", "DD+ 5.1", "ITA", "ENG"]
+
+
+def test_original_language_codec():
+    assert acodec(track("AC-3", 6, "ITA"), track("E-AC-3", 6, "ENG"), track("DTS XLL", 6, "JPN"),
+                  original_language="ja") == ["DD 5.1", "DTS-HD MA 5.1", "ITA", "JPN", "ENG"]
+
+
+def test_other_languages_only_add_the_flag():
+    assert acodec(track("AC-3", 6, "FRA"), track("MLP FBA 16-ch", 8, "GER"), track("AC-3", 6, "ITA"),
+                  track("AAC LC", 2, "ENG"), original_language="en") == [
+        "DD 5.1", "AAC 2.0", "ITA", "ENG", "FRA", "GER"]
+
+
+def test_unknown_original_language_is_english():
+    assert acodec(track("AC-3", 6, "ITA"), track("E-AC-3", 6, "ENG"), track("DTS XLL", 6, "JPN")) == [
+        "DD 5.1", "DD+ 5.1", "ITA", "ENG", "JPN"]
+
+
+def test_italian_original_language():
+    assert acodec(track("AC-3", 6, "ITA"), track("DTS XLL", 6, "ITA"), track("E-AC-3", 6, "ENG"),
+                  original_language="it") == ["DTS-HD MA 5.1", "ITA", "ENG"]
+
+
+def test_channels_break_ties():
+    assert acodec(track("AC-3", 2, "ITA"), track("AC-3", 6, "ITA")) == ["DD 5.1", "ITA"]
+
+
+def test_same_codec_is_written_once():
+    assert acodec(track("AC-3", 6, "ITA"), track("AC-3", 6, "ENG")) == ["DD 5.1", "ITA", "ENG"]
+
+
+def test_untagged_tracks_fill_up_to_two():
+    assert acodec(track("AC-3", 6, "ITA"), track("AAC LC", 2), track("DTS XLL", 6)) == [
+        "DD 5.1", "DTS-HD MA 5.1", "ITA"]
+    assert acodec(track("AC-3", 6, "ITA"), track("AAC LC", 2, "ENG"), track("DTS XLL", 6)) == [
+        "DD 5.1", "AAC 2.0", "ITA", "ENG"]
+    assert acodec(track("AC-3", 6, "ITA"), track("AC-3", 6, "ENG"), track("DTS XLL", 6)) == [
+        "DD 5.1", "DTS-HD MA 5.1", "ITA", "ENG"]
+
+
+def test_untagged_tracks_only():
+    assert acodec(track("AC-3", 6), track("AAC LC", 2), track("E-AC-3", 6)) == ["DD+ 5.1", "DD 5.1"]
+
+
+def test_title_is_rebuilt_with_the_original_language():
+    audio = [track("AC-3", 6, "ITA"), track("E-AC-3", 6, "ENG"), track("DTS XLL", 6, "JPN")]
+    mediafile = SimpleNamespace(video_track=[], audio_track=audio, subtitle_track=[])
+    media = SimpleNamespace(mediafile=mediafile, torrent_pack=False, resolution="1080p", pack=None)
+    search = SearchTags(filename="Movie.2020.1080p.BluRay.REMUX-GRP.mkv", title="Movie", year="2020", season=None,
+                        episode=None, media=media, tags_position=["title", "year", "multi", "acodec"],
+                        tags_list=TAGS_LIST, sign_list={}, ban_list={"dummy": "banned"}, releaser_sign="")
+    title, _ = search.process()
+    assert title == "Movie 2020 MULTI DD 5.1 DD+ 5.1 ITA ENG JPN"
+    title, _ = search.set_original_language("ja")
+    assert title == "Movie 2020 MULTI DD 5.1 DTS-HD MA 5.1 ITA JPN ENG"