ittup 1.2.3__tar.gz → 1.4.0__tar.gz

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

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

{ittup-1.2.3 → ittup-1.4.0}/ittup/common/command.py

@@ -70,6 +70,12 @@ class CommandLine:
         upload_group.add_argument("-personal", "--personal", action="store_true", help="Personal release")
         upload_group.add_argument("-ftp", "--ftp", action="store_true", help="Connect FTP")
 
+        # Freeleech of the uploaded torrents
+        freeleech_group = upload_group.add_mutually_exclusive_group()
+        for percent in (25, 50, 75, 100):
+            freeleech_group.add_argument(f"-fl{percent}", f"--freeleech{percent}", dest="freeleech",
+                                         action="store_const", const=percent, help=f"Freeleech {percent}%%")
+
         # Removed flags: ITTup uploads only to ItaTorrents. Without this '-mt' would be parsed as '-m t'
         upload_group.add_argument("-mt", "--mt", "-tracker", "--tracker", nargs='?', action=RemovedFlag,
                                   help=argparse.SUPPRESS)

{ittup-1.2.3 → ittup-1.4.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.3 → ittup-1.4.0}/ittup/common/external_services/theMovieDB/core/api.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import os
+import re
 import hashlib
 from datetime import datetime
 
@@ -32,6 +33,10 @@ from ittup.view import custom_console
 from ittup.core import config_settings
 
 base_url = "https://api.themoviedb.org/3"
+
+# The title ends at the year, the season or the resolution
+TITLE_END = re.compile(r"\(?(?<![0-9])(?:19|20)\d{2}(?![0-9])\)?|(?<![a-z0-9])S\d{1,2}(?:E\d+)?(?![a-z0-9])|"
+                       r"(?<![0-9])\d{3,4}[pi](?![a-z0-9])", re.IGNORECASE)
 ENABLE_LOG = True
 T = TypeVar('T')
 
@@ -235,6 +240,26 @@ 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 italian_details(self, video_id: int, category: str) -> dict | None:
+        """ Details of the movie or tv show in Italian (title, seasons..), whatever the preferred language """
+        if not video_id:
+            return None
+        if endpoint_class := self.ENDPOINTS.get(category):
+            request = {**endpoint_class.details(video_id), 'datatype': dict, 'params': {'language': 'it-IT'}}
+            response = self.request(endpoint=request)
+            if response:
+                return response[0]
+        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)
@@ -273,6 +298,8 @@ class DbOnline(TmdbAPI):
         self.category = category
         self.imdb_id = None
         self.tvdb_id = None
+        self.no_title = no_title
+        self.relaxed_year = False
 
         # Load the cache file
         self.cache = None
@@ -366,9 +393,18 @@ class DbOnline(TmdbAPI):
         return False
 
     def year_matches(self, result: T) -> bool:
-        """ False only when both years are known and they differ """
+        """
+        False only when both years are known and they differ
+        With relaxed_year a movie may differ by one year and a tv show may have the year of a later season
+        """
         if result.get_date() and self.media.guess_filename.guessit_year:
-            return datetime.strptime(result.get_date(), '%Y-%m-%d').year == self.media.guess_filename.guessit_year
+            tmdb_year = datetime.strptime(result.get_date(), '%Y-%m-%d').year
+            year = self.media.guess_filename.guessit_year
+            if not self.relaxed_year:
+                return tmdb_year == year
+            if self.category == 'tv':
+                return year >= tmdb_year - 1
+            return abs(tmdb_year - year) <= 1
         return True
 
     def debug_scores(self, result: T, alternatives: list[T] | None, translations: list[T] | None) -> None:
@@ -406,7 +442,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 +452,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
 
@@ -440,7 +479,8 @@ class DbOnline(TmdbAPI):
                 return search_results
 
         # or start an on-line search
-        results = self._search(self.query, self.category)
+        main_query = self.query
+        result, results = self.search_queries()
 
         # Use imdb_id when tmdb_id is not available
         tvdb_result = self.tvdb_search()
@@ -449,7 +489,7 @@ class DbOnline(TmdbAPI):
             self.imdb_id = tvdb_result.get('imdb_id', None)
 
         if results:
-            if result := self.is_like(results):
+            if result:
                 # Get the trailer
                 trailer_key = self.trailer(result.id)
                 keywords_list = self.keywords(result.id)
@@ -463,7 +503,7 @@ class DbOnline(TmdbAPI):
                 self.print_results(results=search_results)
                 # Write to the cache if it is enabled
                 if config_settings.user_preferences.CACHE_DBONLINE:
-                    self.cache[self.hash_key(self.query)] = search_results
+                    self.cache[self.hash_key(main_query)] = search_results
                 # return the result
                 return search_results
 
@@ -490,6 +530,65 @@ class DbOnline(TmdbAPI):
             self.cache[self.hash_key(self.query)] = search_results
         return search_results
 
+    def search_queries(self) -> tuple[T | None, list[T] | None]:
+        """
+        Search TMDB with the title from the file name, then with the other titles written in the name
+        (es. '(500) Days of Summer', the title in parentheses). Each query is checked first with the exact year,
+        then with a tolerance (movies released at the end of the year, the year of a season..)
+        Returns the result found and the results of the first query (None if TMDB doesn't answer)
+        On success self.query is the query that found the result, otherwise the first query
+        """
+        queries = [self.query] if self.no_title else self.title_queries(self.query, self.media.title)
+        responses = {}
+        for relaxed in (False, True):
+            self.relaxed_year = relaxed
+            for query in queries:
+                if query not in responses:
+                    responses[query] = self._search(query, self.category)
+                    # No response from TMDB
+                    if responses[query] is None:
+                        if query == queries[0]:
+                            return None, None
+                        responses[query] = []
+                self.query = query
+                result = self.is_like(responses[query]) if responses[query] else None
+                if result:
+                    if query != queries[0] or relaxed:
+                        custom_console.bot_log(f"TMDB: found with the title '{query}'"
+                                               f"{' and a year tolerance' if relaxed else ''}")
+                    self.relaxed_year = False
+                    return result, responses[query]
+        self.relaxed_year = False
+        self.query = queries[0]
+        return None, responses[queries[0]]
+
+    @staticmethod
+    def title_queries(query: str, name: str) -> list[str]:
+        """
+        TMDB queries: the title from guessit, then the name before the year, the season or the resolution,
+        and the titles in parentheses ('Lo Chiamavano Jeeg Robot (They Call Me Jeeg) (2015)')
+        """
+        queries = [query]
+        name = re.sub(r"\.(mkv|mp4|avi|m2ts|ts|mov|wmv|m4v|mpg|mpeg|webm)$", "", name, flags=re.IGNORECASE)
+        # Dots and underscores as spaces, but not in the acronyms (S.W.A.T.)
+        name = re.sub(r"(?<=[^\W\d_]{2})[._]|[._](?=[^\W\d_]{2})|_", " ", name)
+        prefix = TITLE_END.split(name, maxsplit=1)[0]
+        prefix = re.sub(r"[\[{].*", "", prefix).strip(" -.")
+        # Titles in parentheses, not numbers like '(500)'
+        groups = [group for group in re.findall(r"\(([^()]+)\)", prefix) if re.search(r"[^\W\d_]{2}", group)]
+        # The whole prefix, e.g. '(500) Days of Summer'
+        queries.append(re.sub(r"[()]", "", prefix))
+        # The prefix without the parentheses and each title in parentheses
+        queries.append(re.sub(r"\([^()]*\)", "", prefix))
+        queries.extend(groups)
+
+        unique = []
+        for item in queries:
+            item = re.sub(r"\s+", " ", item or "").strip(" -.")
+            if item and item.lower() not in [u.lower() for u in unique]:
+                unique.append(item)
+        return unique[:4]
+
     def add_external_ids(self, video_id: int, override: bool = False) -> None:
         """ Set the IMDB and TVDB IDs from TMDB; override=False keeps the ones already known """
         ext = self.external_ids(video_id=video_id, category=self.category)

ittup-1.4.0/ittup/common/rename.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+
+from ittup.view import custom_console
+
+# Characters the tracker (UNIT3D) doesn't accept in the names of the torrent files
+INVALID_CHARS = re.compile(r'[<>:"/\\|?*\x00-\x1f]')
+
+
+def safe_name(name: str) -> str:
+    """
+    Name without the characters refused by the tracker: 'Titolo: Sub' -> 'Titolo - Sub'
+    The extension is kept, the trailing dots and spaces are removed
+    """
+    stem, ext = os.path.splitext(name)
+    # Keep only a real extension (es. '.mkv'), not the end of 'Mr. Robot'
+    if not re.fullmatch(r"\.[A-Za-z0-9]{1,5}", ext):
+        stem, ext = name, ""
+    if " " in stem:
+        stem = re.sub(r"\s*:\s*", " - ", stem)
+    else:
+        stem = stem.replace(":", ".")
+    stem = INVALID_CHARS.sub("", stem)
+    stem = re.sub(r"\s{2,}", " ", stem)
+    stem = re.sub(r"\.{2,}", ".", stem)
+    stem = re.sub(r"(\s-)+\s", " - ", stem)
+    return stem.strip(" .") + ext
+
+
+def is_valid_name(name: str) -> bool:
+    return not INVALID_CHARS.search(name) and name == name.rstrip(" .")
+
+
+def rename_path(path: str, new_name: str) -> str:
+    """
+    Rename a file or a folder in the same folder. Returns the new path, the old one if it can't be renamed
+    """
+    new_path = os.path.join(os.path.dirname(path), new_name)
+    if new_path == path:
+        return path
+    if os.path.exists(new_path):
+        custom_console.bot_error_log(f"Can't rename '{path}': '{new_name}' already exists")
+        return path
+    try:
+        os.rename(path, new_path)
+    except OSError as e:
+        custom_console.bot_error_log(f"Can't rename '{path}': {e}")
+        return path
+    custom_console.bot_warning_log(f"Renamed '{os.path.basename(path)}' -> '{new_name}'")
+    return new_path
+
+
+def rename_invalid(path: str) -> str:
+    """
+    Rename the file, or the folder and everything in it, whose names have characters refused by the tracker
+    Returns the new path
+    """
+    path = os.path.normpath(path)
+    if os.path.isdir(path):
+        for root, dirs, files in os.walk(path, topdown=False):
+            for name in files + dirs:
+                if not is_valid_name(name):
+                    rename_path(os.path.join(root, name), safe_name(name))
+    name = os.path.basename(path)
+    if is_valid_name(name):
+        return path
+    return rename_path(path, safe_name(name))
+
+
+def title_name(display_name: str) -> str:
+    """
+    File name from the title shown on the tracker, with dots:
+    'Spider-Man: No Way Home 2021 1080p WEB-DL H.264-SIGN' -> 'Spider-Man.No.Way.Home.2021.1080p.WEB-DL.H.264-SIGN'
+    """
+    name = INVALID_CHARS.sub(" ", display_name)
+    name = re.sub(r"\s+-\s+", ".", name.strip())
+    name = re.sub(r"\s+", ".", name)
+    name = re.sub(r"\.{2,}", ".", name)
+    return name.strip(".")
+
+
+def episode_name(name: str, pack: str | None, season: int | None, episode: int | None) -> str | None:
+    """
+    Name of an episode of a pack: the pack tag of the title is replaced by its SxxExx
+    None if the episode or the pack tag are unknown
+    """
+    if not pack or season is None or episode is None:
+        return None
+    pattern = rf"(?<![^.]){re.escape(pack)}(?![^.])"
+    if not re.search(pattern, name):
+        return None
+    return re.sub(pattern, f"S{int(season):02d}E{int(episode):02d}", name, count=1)
+
+
+def rename_to_title(path: str, display_name: str, video_files: list[str], pack: str | None,
+                    episodes: dict[str, tuple[int | None, int | None]]) -> tuple[str, dict[str, str]]:
+    """
+    Rename a file, or a folder and its video files, as the title shown on the tracker
+
+    Args:
+        path: the file or the folder of the torrent
+        display_name: the title shown on the tracker
+        video_files: the video files in the folder (names)
+        pack: the season tag of the title (es. 'S04') for a tv pack
+        episodes: (season, episode) of each video file of a pack
+
+    Returns:
+        the new path and the new name of each renamed file of the folder
+    """
+    name = title_name(display_name)
+    if os.path.isfile(path):
+        _, ext = os.path.splitext(path)
+        return rename_path(path, name + ext), {}
+
+    renamed = {}
+    for file in video_files:
+        _, ext = os.path.splitext(file)
+        if pack:
+            new_name = episode_name(name, pack, *episodes.get(file, (None, None)))
+        else:
+            # A movie folder: only its single video file takes the title
+            new_name = name if len(video_files) == 1 else None
+        if not new_name:
+            continue
+        new_path = rename_path(os.path.join(path, file), new_name + ext)
+        if new_path != os.path.join(path, file):
+            renamed[file] = os.path.basename(new_path)
+    return rename_path(path, name), renamed

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

@@ -147,6 +147,7 @@ class UserPreferences(BaseModel):
     CACHE_DBONLINE: bool = False
     TMDB_DEBUG: bool = False
     PERSONAL_RELEASE: bool = False
+    RENAME_FILES: bool = False
     FAST_LOAD: int = 0
     MY_SIGN: str | None = None
     MY_URL: str | None = None
@@ -460,13 +461,14 @@ class Config(BaseModel):
                 field = field.upper()
 
                 # New attribute added to an existing json file with an empty value: use the default
-                if field == 'TMDB_DEBUG' and section[field] == '':
+                if field in ['TMDB_DEBUG', 'RENAME_FILES'] and section[field] == '':
                     section[field] = 'False'
                 if field == 'WATCHER_TIMEOUT' and section[field] == '':
                     section[field] = UserPreferences.model_fields['WATCHER_TIMEOUT'].default
 
                 if field in ['DUPLICATE_ON', 'SKIP_DUPLICATE', 'SKIP_TMDB', 'SKIP_YOUTUBE', 'RESIZE_SCSHOT', 'ANON',
-                             'WEBP_ENABLED', 'CACHE_SCR', 'CACHE_DBONLINE', 'TMDB_DEBUG', 'PERSONAL_RELEASE']:
+                             'WEBP_ENABLED', 'CACHE_SCR', 'CACHE_DBONLINE', 'TMDB_DEBUG', 'PERSONAL_RELEASE',
+                             'RENAME_FILES']:
                     section[field] = Validate.boolean(value=section[field], field_name=field)
 
                 if field in ['TORRENT_COMMENT', 'WATCHER_PATH']:
@@ -653,6 +655,7 @@ class Load:
                 "CACHE_DBONLINE": "False",
                 "TMDB_DEBUG": "False",
                 "PERSONAL_RELEASE": "False",
+                "RENAME_FILES": "False",
                 "FAST_LOAD": "0",
                 "RELEASER_SIGN": "",
                 "MY_SIGN": "",

{ittup-1.2.3 → ittup-1.4.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
@@ -142,6 +151,16 @@ class SearchTags(object):
         tag_esc = re.sub(r'([A-Z])(\d+)', r'\1[._-]?\2', tag_esc)
         return tag_esc
 
+    def expand_platform_rip(self, filename: str) -> str:
+        """
+        Split a platform rip into the platform and the WEBRip source (es. 'NFRip' -> 'NF WEBRip')
+        """
+        platforms = [tag for tag, category in self.TAG_TYPES.items() if category == "platform"]
+        if not platforms:
+            return filename
+        pattern = r'(?<![a-z0-9])(' + "|".join(re.escape(tag) for tag in platforms) + r')rip(?![a-z0-9])'
+        return re.sub(pattern, r'\1 WEBRip', filename, flags=re.IGNORECASE)
+
     def build_title(self, dictionary: dict) -> str:
         # /// Build the title
         build = []
@@ -179,10 +198,13 @@ class SearchTags(object):
                 # Save a regex pattern for each category
             patterns.append([norm, category])
 
+        # NFRip -> NF WEBRip: the streaming platform and the source
+        filename = self.expand_platform_rip(self.filename)
+
         # Run regex
         for p, category in patterns:
             regex = re.compile(r'(?<!\w)' + p + r'(?!\w)', re.IGNORECASE)
-            matches = regex.findall(self.filename)
+            matches = regex.findall(filename)
             if matches:
                 # Normalize Tag_list
                 normalized_tag = TAG_NORMALIZE.get(matches[0].upper(), None)
@@ -267,6 +289,36 @@ 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 set_title(self, title: str) -> tuple[str, dict]:
+        """
+        Rebuild the title with a new media title (es. the Italian title from TMDB)
+        """
+        self.title = title
+        self.tags_dict.update({'title': title})
+        # The part is already in the new title (es. 'Wicked - Parte 2')
+        if re.search(r'(?<![a-z])part[ei]?(?![a-z])', title, re.IGNORECASE):
+            self.tags_dict.pop('part', None)
+        return self.ordered_title()
+
+    def set_season(self, se_str: str) -> tuple[str, dict]:
+        """
+        Rebuild the title with a new season tag (es. 'S04' for a pack with every episode of the season)
+        """
+        self.tags_dict.update({'season': se_str})
+        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 +328,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 +372,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.4.0/ittup/common/trackers/trackers.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+import os
+import re
+
+from dataclasses import dataclass
+from ittup.common.utility import ManageTitles
+from ittup.common.trackers.tags_list import TAGS_LIST
+from . import tracker_list
+
+@dataclass
+class TRACKData:
+    category: dict[str, int]
+    freelech: dict[str, int]
+    type_id: dict[str, int]
+    resolution: dict[str, int]
+    codec: list
+
+    @classmethod
+    def load_from_module(cls, tracker_name: str) -> "TRACKData":
+        """
+        Load tracker data from module
+        """
+        tracker_data= tracker_list[tracker_name.upper()]
+
+        return cls(
+            category=tracker_data.get("CATEGORY"),
+            freelech=tracker_data.get("FREELECH"),
+            type_id=tracker_data.get("TYPE_ID"),
+            resolution=tracker_data.get("RESOLUTION"),
+            codec=tracker_data.get("CODEC"),
+        )
+
+    def filter_type(self, *names: str) -> int:
+        """
+        Tracker type ID from the release names (es. the folder name, then the file name)
+        The first name with a source (WEB-DL, REMUX, WEBRip..) wins, so the type always follows the source
+        written in the title. Without a source, a codec in the name means 'encode'
+        """
+        names = [os.path.basename(str(name)) for name in names if name]
+
+        # Caso 1: Cerca la sorgente nel nome, dalla piu' importante
+        for name in names:
+            found = self.type_tags(name)
+            if found:
+                return self.type_id[min(found, key=type_priority)]
+
+        # Caso 2: Se non trova un TYPE_ID, cerca un codec e ritorna 'encode'
+        for name in names:
+            word_list = ManageTitles.clean(name).replace("-", " ").lower().split(" ")
+            if any(word in self.codec for word in word_list):
+                return self.type_id.get("encode", -1)
+        return self.type_id.get("altro", -1)
+
+    def type_tags(self, name: str) -> list[str]:
+        """
+        TYPE_ID tags written in the name. A longer tag hides the shorter ones inside it (WEB-DLMux is not DLMux)
+        """
+        name = re.sub(r"[._\s()\[\]{}+,]+", " ", name.lower())
+        # Skip the title: the tags start from the year, the season or the resolution ('Charlotte's Web 2006 BluRay')
+        start = TITLE_END.search(name)
+        if start and start.start() > 0:
+            name = name[start.start():]
+        # NFRip, AMZNRip.. are WEBRip from a streaming platform
+        name = PLATFORM_RIP.sub("webrip", name)
+        name = re.sub(r"(?<![a-z0-9])full disc(?![a-z0-9])", "full-disc", name)
+
+        found = []
+        for tag in sorted(self.type_id, key=len, reverse=True):
+            # 'altro' is the default type, not a tag (es. 'Un altro giro')
+            if tag == "altro":
+                continue
+            pattern = re.compile(rf"(?<![a-z0-9]){re.escape(tag)}(?![a-z0-9])")
+            if pattern.search(name):
+                found.append(tag)
+                # Hide the matched tag from the shorter ones
+                name = pattern.sub(" ", name)
+        return found
+
+
+# Type tags from the most to the least important: the release source before the generic tags
+# (BluRay, HEVC, FullHD..) and before the file extensions. Tags not in the list come last
+TYPE_PRIORITY = [
+    "full-disc", "fulldisc",
+    "bdmux", "web-dlmux", "dlmux", "webmux",
+    "bd-untouched", "untouched", "bdremux", "remux", "vu", "vh",
+    "web-dl", "webdl", "web",
+    "webrip",
+    "hdtv",
+    "bdrip", "dvdrip",
+    "cinema-md", "hdts", "wrs", "md",
+    "3d",
+    "encode", "hdrip", "bluray", "hevc", "fullhd",
+]
+
+
+def type_priority(tag: str) -> int:
+    return TYPE_PRIORITY.index(tag) if tag in TYPE_PRIORITY else len(TYPE_PRIORITY)
+
+
+# Year, season or resolution after the title
+TITLE_END = re.compile(r"(?<![a-z0-9])(?:(?:19|20)\d{2}|s\d{1,2}(?:e\d+)?|\d{3,4}[pi])(?![a-z0-9])")
+
+# NFRip, AMZNRip, DSNPRip..
+PLATFORM_RIP = re.compile(
+    r"(?<![a-z0-9])(?:" + "|".join(re.escape(tag.lower()) for tag, category in TAGS_LIST.items()
+                                    if category == "platform") + r")rip(?![a-z0-9])")