Add support for parsing non-english chars along with english title & More language patterns

PTN/__init__.py

@@ -1,22 +1,23 @@
 #!/usr/bin/env python
 
-import pkgutil
-import sys
-
-# Regex in python 2 is very slow so we check if the faster 'regex' library is available.
-faster_regex = pkgutil.find_loader("regex")
-if faster_regex is not None and sys.version_info[0] < 3:
-    re = faster_regex.load_module("regex")
-else:
-    re = pkgutil.find_loader("re").load_module("re")
-
 from .parse import PTN
 
 __author__ = "Giorgio Momigliano"
 __email__ = "[email protected]"
 __version__ = "2.8.2"
 __license__ = "MIT"
 
+# Singleton instance of PTN
+_ptn_instance = PTN()
+
+
+def parse(name: str, standardise: bool = True, coherent_types: bool = False) -> dict:
+    """
+    Parse the torrent title into its components.
 
-def parse(name, standardise=True, coherent_types=False):
-    return PTN().parse(name, standardise, coherent_types)
+    :param name: The torrent name to parse.
+    :param standardise: Whether to standardise the parsed values.
+    :param coherent_types: Whether to ensure coherent types in the parsed results.
+    :return: A dictionary of parsed components.
+    """
+    return _ptn_instance.parse(name, standardise, coherent_types)

PTN/extras.py

@@ -1,49 +1,66 @@
 #!/usr/bin/env python
+from typing import List, Tuple, Union
 
 # Helper functions and constants for patterns.py
 
-delimiters = "[\.\s\-\+_\/(),]"
+delimiters = r"[\.\s\-\+_\/(),]"
 
 langs = [
-    ("rus(?:sian)?", "Russian"),
-    ("(?:True)?fre?(?:nch)?", "French"),
-    ("(?:nu)?ita(?:liano?)?", "Italian"),
-    ("castellano|spa(?:nish)?|esp?", "Spanish"),
-    ("swedish", "Swedish"),
-    ("dk|dan(?:ish)?", "Danish"),
-    ("ger(?:man)?|deu(?:tsch)?", "German"),
-    ("nordic", "Nordic"),
-    ("exyu", "ExYu"),
-    ("chs|chi(?:nese)?", "Chinese"),
-    ("hin(?:di)?", "Hindi"),
-    ("polish|poland|pl", "Polish"),
-    ("mandarin", "Mandarin"),
-    ("kor(?:ean)?", "Korean"),
-    ("ben(?:gali)?|bangla", "Bengali"),
-    ("kan(?:nada)?", "Kannada"),
-    ("tam(?:il)?", "Tamil"),
-    ("tel(?:ugu)?", "Telugu"),
-    ("mar(?:athi)?", "Marathi"),
-    ("mal(?:ayalam)?", "Malayalam"),
-    ("japanese|ja?p", "Japanese"),
-    ("interslavic", "Interslavic"),
-    ("ara(?:bic)?", "Arabic"),
-    ("urdu", "Urdu"),
-    ("punjabi", "Punjabi"),
-    ("portuguese", "Portuguese"),
-    ("albanian?", "Albanian"),
-    ("egypt(?:ian)?", "Egyptian"),
-    ("en?(?:g(?:lish)?)?", "English"),  # Must be at end, matches just an 'e'
+    (r"rus(?:sian)?|russo", "Russian"),
+    (r"(?:True)?fre?(?:nch)?|fr(?:ench|a|e|anc[eê]s)?", "French"),
+    (r"(?:nu)?ita(?:liano?)?", "Italian"),
+    (r"castellano|spa(?:nish)?|esp?", "Spanish"),
+    (r"swedish", "Swedish"),
+    (r"dk|dan(?:ish)?", "Danish"),
+    (r"ger(?:man)?|deu(?:tsch)?|alem[aã]o", "German"),
+    (r"nordic", "Nordic"),
+    (r"exyu", "ExYu"),
+    (r"chs|chi(?:nese)?|(?:mand[ae]rin|ch[sn])|chin[eê]s|zh-hans", "Chinese"),
+    (r"hin(?:di)?", "Hindi"),
+    (r"polish|poland|pl", "Polish"),
+    (r"kor(?:ean)?|coreano", "Korean"),
+    (r"ben(?:gali)?|bangla", "Bengali"),
+    (r"kan(?:nada)?", "Kannada"),
+    (r"t[aâ]m(?:il)?", "Tamil"),
+    (r"tel(?:ugu)?", "Telugu"),
+    (r"mar(?:athi)?", "Marathi"),
+    (r"mal(?:ayalam)?", "Malayalam"),
+    (r"guj(?:arati)?", "Gujarati"),
+    (r"pun(?:jabi)?", "Punjabi"),
+    (r"ori(?:ya)?", "Oriya"),
+    (r"japanese|ja?p|jpn|japon[eê]s", "Japanese"),
+    (r"interslavic", "Interslavic"),
+    (r"ara(?:bic)?", "Arabic"),
+    (r"urdu", "Urdu"),
+    (r"tur(?:kish)?|tr", "Turkish"),
+    (r"tailand[eê]s|thai?", "Thai"),
+    (r"tagalog", "Tagalog"),
+    (r"ind(?:onesian)?", "Indonesian"),
+    (r"vie(?:tnamese)?", "Vietnamese"),
+    (r"heb(?:rew)?", "Hebrew"),
+    (r"gre(?:ek)?", "Greek"),
+    (r"cz(?:ech)?", "Czech"),
+    (r"hun(?:garian)?", "Hungarian"),
+    (r"ukr(?:ainian)?", "Ukrainian"),
+    (r"fin(?:nish)?", "Finnish"),
+    (r"nor(?:wegian)?", "Norwegian"),
+    (r"sin(?:hala)?", "Sinhala"),
+    (r"dutch|nl", "Dutch"),
+    (r"p[ua]n(?:jabi)?", "Punjabi"),
+    (r"por(?:tuguese)?|portugu[eèê]s[ea]?|p[rt]|port?", "Portuguese"),
+    (r"alb(?:anian?)?|albanais", "Albanian"),
+    (r"egypt(?:ian)?|egy", "Egyptian"),
+    (r"en?(?:g(?:lish)?)?|ing(?:l[eéê]s)?", "English"),  # Must be at end, matches just an 'e'
 ]
 
 genres = [
-    ("Sci-?Fi", "Sci-Fi"),
-    ("Drama", "Drama"),
-    ("Comedy", "Comedy"),
-    ("West(?:\.|ern)?", "Western"),
-    ("Action", "Action"),
-    ("Adventure", "Adventure"),
-    ("Thriller", "Thriller"),
+    (r"Sci-?Fi", "Sci-Fi"),
+    (r"Drama", "Drama"),
+    (r"Comedy", "Comedy"),
+    (r"West(?:\.|ern)?", "Western"),
+    (r"Action", "Action"),
+    (r"Adventure", "Adventure"),
+    (r"Thriller", "Thriller"),
 ]
 
 # Match strings like "complete series" for tv seasons/series, matching within the final title string.
@@ -78,45 +95,36 @@
 # or a season. So if we have a language in the title it won't cause issues by getting matched.
 # Empty list indicates to always do so, as opposed to matching specific regexes.
 patterns_ignore_title = {
-    "language": [],
-    "audio": ["LiNE"],
-    "network": ["Hallmark"],
+    "languages": [],
+    "audio": [r"LiNE"],
+    "network": [r"Hallmark"],
     "untouched": [],
     "internal": [],
     "limited": [],
     "proper": [],
-    "extended": [r"(EXTENDED{d}(?!(?:CUT|EDITIONS?)))".format(d=delimiters)],
+    "extended": [rf"(EXTENDED{delimiters}(?!(?:CUT|EDITIONS?)))"],
 }
 
-
 channels = [(1, 0), (2, 0), (5, 0), (5, 1), (6, 1), (7, 1)]
 
 
 # Return tuple with regexes for audio name with appended channel types, and without any channels
-def get_channel_audio_options(patterns_with_names):
+def get_channel_audio_options(patterns_with_names: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
     options = []
-    for (audio_pattern, name) in patterns_with_names:
-        for (speakers, subwoofers) in channels:
+    for audio_pattern, name in patterns_with_names:
+        for speakers, subwoofers in channels:
             options.append(
                 (
-                    "((?:{}){}*{}[. \-]?{}(?:ch)?)".format(
-                        audio_pattern, delimiters, speakers, subwoofers
-                    ),
-                    "{} {}.{}".format(name, speakers, subwoofers),
+                    rf"((?:{audio_pattern}){delimiters}*{speakers}[. \-]?{subwoofers}(?:ch)?)",
+                    f"{name} {speakers}.{subwoofers}",
                 )
             )
-        options.append(
-            ("({})".format(audio_pattern), name)
-        )  # After for loop, would match first
-
+        options.append((rf"({audio_pattern})", name))  # After for loop, would match first
     return options
 
 
-def prefix_pattern_with(prefixes, pattern_options, between="", optional=False):
-    if optional:
-        optional_char = "?"
-    else:
-        optional_char = ""
+def prefix_pattern_with(prefixes: Union[str, List[str]], pattern_options: Union[str, List[Union[str, Tuple]]], between: str = "", optional: bool = False) -> List[Union[str, Tuple]]:
+    optional_char = "?" if optional else ""
     options = []
     if not isinstance(prefixes, list):
         prefixes = [prefixes]
@@ -126,28 +134,19 @@ def prefix_pattern_with(prefixes, pattern_options, between="", optional=False):
         for pattern_option in pattern_options:
             if isinstance(pattern_option, str):
                 options.append(
-                    "(?:{}){}(?:{})?({})".format(
-                        prefix, optional_char, between, pattern_option
-                    )
+                    rf"(?:{prefix}){optional_char}(?:{between})?({pattern_option})"
                 )
             else:
                 options.append(
                     (
-                        "(?:{}){}(?:{})?({})".format(
-                            prefix, optional_char, between, pattern_option[0]
-                        ),
-                    )
-                    + pattern_option[1:]
+                        rf"(?:{prefix}){optional_char}(?:{between})?({pattern_option[0]})",
+                    ) + pattern_option[1:]
                 )
-
     return options
 
 
-def suffix_pattern_with(suffixes, pattern_options, between="", optional=False):
-    if optional:
-        optional_char = "?"
-    else:
-        optional_char = ""
+def suffix_pattern_with(suffixes: Union[str, List[str]], pattern_options: Union[str, List[Union[str, Tuple]]], between: str = "", optional: bool = False) -> List[Union[str, Tuple]]:
+    optional_char = "?" if optional else ""
     options = []
     if not isinstance(suffixes, list):
         suffixes = [suffixes]
@@ -158,36 +157,17 @@ def suffix_pattern_with(suffixes, pattern_options, between="", optional=False):
             if isinstance(pattern_option, tuple):
                 options.append(
                     (
-                        "({})(?:{})?(?:{}){}".format(
-                            pattern_option[0], between, suffix, optional_char
-                        ),
-                    )
-                    + pattern_option[1:]
+                        rf"({pattern_option[0]})(?:{between})?(?:{suffix}){optional_char}",
+                    ) + pattern_option[1:]
                 )
             else:
                 options.append(
-                    "({})(?:{})?(?:{}){}".format(
-                        pattern_option, between, suffix, optional_char
-                    )
+                    rf"({pattern_option})(?:{between})?(?:{suffix}){optional_char}"
                 )
-
     return options
 
 
-# Link a regex-tuple list into a single regex (to be able to use elsewhere while
-# maintaining standardisation functionality).
-def link_patterns(pattern_options):
+def link_patterns(pattern_options: Union[str, List[Union[str, Tuple]]]) -> str:
     if not isinstance(pattern_options, list):
         return pattern_options
-    return (
-        "(?:"
-        + "|".join(
-            [
-                pattern_option[0]
-                if isinstance(pattern_option, tuple)
-                else pattern_option
-                for pattern_option in pattern_options
-            ]
-        )
-        + ")"
-    )
+    return rf"(?:{'|'.join([pattern_option[0] if isinstance(pattern_option, tuple) else pattern_option for pattern_option in pattern_options])})"