quasarr 2.2.0__tar.gz → 2.3.0__tar.gz

{quasarr-2.2.0 → quasarr-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quasarr
-Version: 2.2.0
+Version: 2.3.0
 Summary: Quasarr connects JDownloader with Radarr, Sonarr and LazyLibrarian. It also decrypts links protected by CAPTCHAs.
 Home-page: https://github.com/rix1337/Quasarr
 Author: rix1337

{quasarr-2.2.0 → quasarr-2.3.0}/quasarr/__init__.py

@@ -100,38 +100,12 @@ def run():
         shared_state.update("database", DataBase)
         supported_hostnames = extract_allowed_keys(Config._DEFAULT_CONFIG, 'Hostnames')
         shared_state.update("sites", [key.upper() for key in supported_hostnames])
-        shared_state.update("user_agent", "")  # will be set by FlareSolverr or fallback
+        # Set fallback user agent immediately so it's available while background check runs
+        shared_state.update("user_agent", FALLBACK_USER_AGENT)
         shared_state.update("helper_active", False)
 
         print(f'Config path: "{config_path}"')
 
-        # Check if FlareSolverr was previously skipped
-        skip_flaresolverr_db = DataBase("skip_flaresolverr")
-        flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
-
-        flaresolverr_url = Config('FlareSolverr').get('url')
-        if not flaresolverr_url and not flaresolverr_skipped:
-            flaresolverr_config(shared_state)
-            # Re-check after config - user may have skipped
-            flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
-            flaresolverr_url = Config('FlareSolverr').get('url')
-
-        if flaresolverr_skipped:
-            info('FlareSolverr setup skipped by user preference')
-            info('Some sites (AL) will not work without FlareSolverr. Configure it later in the web UI.')
-            # Set fallback user agent
-            shared_state.update("user_agent", FALLBACK_USER_AGENT)
-            print(f'User Agent (fallback): "{FALLBACK_USER_AGENT}"')
-        elif flaresolverr_url:
-            print(f'Flaresolverr URL: "{flaresolverr_url}"')
-            flaresolverr_check = check_flaresolverr(shared_state, flaresolverr_url)
-            if flaresolverr_check:
-                print(f'User Agent: "{shared_state.values["user_agent"]}"')
-            else:
-                info('FlareSolverr check failed - using fallback user agent')
-                shared_state.update("user_agent", FALLBACK_USER_AGENT)
-                print(f'User Agent (fallback): "{FALLBACK_USER_AGENT}"')
-
         print("\n===== Hostnames =====")
         try:
             if arguments.hostnames:
@@ -181,7 +155,7 @@ def run():
 
         # Check credentials for login-required hostnames
         skip_login_db = DataBase("skip_login")
-        login_required_sites = ['al', 'dd', 'nx', 'dl']
+        login_required_sites = ['al', 'dd', 'dl', 'nx']
 
         for site in login_required_sites:
             hostname = Config('Hostnames').get(site)
@@ -239,6 +213,13 @@ def run():
             info(f'CAPTCHA-Solution required for {package_count} package{'s' if package_count > 1 else ''} at: '
                  f'"{shared_state.values["external_address"]}/captcha"!')
 
+        flaresolverr = multiprocessing.Process(
+            target=flaresolverr_checker,
+            args=(shared_state_dict, shared_state_lock),
+            daemon=True
+        )
+        flaresolverr.start()
+
         jdownloader = multiprocessing.Process(
             target=jdownloader_connection,
             args=(shared_state_dict, shared_state_lock),
@@ -259,6 +240,34 @@ def run():
             sys.exit(0)
 
 
+def flaresolverr_checker(shared_state_dict, shared_state_lock):
+    try:
+        shared_state.set_state(shared_state_dict, shared_state_lock)
+
+        # Check if FlareSolverr was previously skipped
+        skip_flaresolverr_db = DataBase("skip_flaresolverr")
+        flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
+
+        flaresolverr_url = Config('FlareSolverr').get('url')
+        if not flaresolverr_url and not flaresolverr_skipped:
+            flaresolverr_config(shared_state)
+            # Re-check after config - user may have skipped
+            flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
+            flaresolverr_url = Config('FlareSolverr').get('url')
+
+        if flaresolverr_skipped:
+            info('FlareSolverr setup skipped by user preference')
+            info('Some sites (AL) will not work without FlareSolverr. Configure it later in the web UI.')
+        elif flaresolverr_url:
+            print(f'Flaresolverr URL: "{flaresolverr_url}"')
+            flaresolverr_check = check_flaresolverr(shared_state, flaresolverr_url)
+            if flaresolverr_check:
+                print(f'Using same User-Agent as FlareSolverr: "{shared_state.values["user_agent"]}"')
+
+    except KeyboardInterrupt:
+        pass
+
+
 def update_checker(shared_state_dict, shared_state_lock):
     try:
         shared_state.set_state(shared_state_dict, shared_state_lock)

quasarr-2.3.0/quasarr/providers/imdb_metadata.py

@@ -0,0 +1,355 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import html
+import re
+from datetime import datetime, timedelta
+from json import loads, dumps
+from urllib.parse import quote
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+
+def _get_db(table_name):
+    """Lazy import to avoid circular dependency."""
+    from quasarr.storage.sqlite_database import DataBase
+    return DataBase(table_name)
+
+
+class IMDbAPI:
+    """Handles interactions with api.imdbapi.dev"""
+    BASE_URL = "https://api.imdbapi.dev"
+
+    @staticmethod
+    def get_title(imdb_id):
+        try:
+            response = requests.get(f"{IMDbAPI.BASE_URL}/titles/{imdb_id}", timeout=30)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            info(f"Error loading imdbapi.dev for {imdb_id}: {e}")
+            return None
+
+    @staticmethod
+    def get_akas(imdb_id):
+        try:
+            response = requests.get(f"{IMDbAPI.BASE_URL}/titles/{imdb_id}/akas", timeout=30)
+            response.raise_for_status()
+            return response.json().get("akas", [])
+        except Exception as e:
+            info(f"Error loading localized titles from IMDbAPI.dev for {imdb_id}: {e}")
+            return []
+
+    @staticmethod
+    def search_titles(query):
+        try:
+            response = requests.get(f"{IMDbAPI.BASE_URL}/search/titles?query={quote(query)}&limit=5", timeout=30)
+            response.raise_for_status()
+            return response.json().get("titles", [])
+        except Exception as e:
+            debug(f"Request on IMDbAPI failed: {e}")
+            return []
+
+
+class IMDbWeb:
+    """Handles fallback interactions by scraping imdb.com"""
+    BASE_URL = "https://www.imdb.com"
+
+    @staticmethod
+    def get_poster(imdb_id, user_agent):
+        headers = {'User-Agent': user_agent}
+        try:
+            request = requests.get(f"{IMDbWeb.BASE_URL}/title/{imdb_id}/", headers=headers, timeout=10).text
+            soup = BeautifulSoup(request, "html.parser")
+            poster_set = soup.find('div', class_='ipc-poster').div.img["srcset"]
+            poster_links = [x for x in poster_set.split(" ") if len(x) > 10]
+            return poster_links[-1]
+        except Exception as e:
+            debug(f"Could not get poster title for {imdb_id} from IMDb: {e}")
+            return None
+
+    @staticmethod
+    def get_localized_title(imdb_id, language, user_agent):
+        headers = {
+            'Accept-Language': language,
+            'User-Agent': user_agent
+        }
+        try:
+            response = requests.get(f"{IMDbWeb.BASE_URL}/title/{imdb_id}/", headers=headers, timeout=10)
+            response.raise_for_status()
+
+            match = re.search(r'<title>(.*?) \(.*?</title>', response.text)
+            if not match:
+                match = re.search(r'<title>(.*?) - IMDb</title>', response.text)
+
+            if match:
+                return match.group(1)
+        except Exception as e:
+            info(f"Error loading IMDb metadata for {imdb_id}: {e}")
+
+        return None
+
+    @staticmethod
+    def search_titles(query, ttype, language, user_agent):
+        headers = {
+            'Accept-Language': language,
+            'User-Agent': user_agent
+        }
+        try:
+            results = requests.get(f"{IMDbWeb.BASE_URL}/find/?q={quote(query)}&s=tt&ttype={ttype}&ref_=fn_{ttype}",
+                                   headers=headers, timeout=10)
+
+            if results.status_code == 200:
+                soup = BeautifulSoup(results.text, "html.parser")
+                props = soup.find("script", text=re.compile("props"))
+                if props:
+                    details = loads(props.string)
+                    return details['props']['pageProps']['titleResults']['results']
+            else:
+                debug(f"Request on IMDb failed: {results.status_code}")
+        except Exception as e:
+            debug(f"IMDb scraping fallback failed: {e}")
+
+        return []
+
+
+class TitleCleaner:
+    @staticmethod
+    def sanitize(title):
+        if not title:
+            return ""
+        sanitized_title = html.unescape(title)
+        sanitized_title = re.sub(r"[^a-zA-Z0-9äöüÄÖÜß&-']", ' ', sanitized_title).strip()
+        sanitized_title = sanitized_title.replace(" - ", "-")
+        sanitized_title = re.sub(r'\s{2,}', ' ', sanitized_title)
+        return sanitized_title
+
+    @staticmethod
+    def clean(title):
+        try:
+            # Regex to find the title part before common release tags
+            # Stops at:
+            # - Year (19xx or 20xx) preceded by a separator
+            # - Language tags (.German, .GERMAN)
+            # - Resolution (.1080p, .720p, etc.)
+            # - Season info (.S01)
+            pattern = r"(.*?)(?:[\.\s](?!19|20)\d{2}|[\.\s]German|[\.\s]GERMAN|[\.\s]\d{3,4}p|[\.\s]S(?:\d{1,3}))"
+            match = re.search(pattern, title)
+            if match:
+                extracted_title = match.group(1)
+            else:
+                extracted_title = title
+
+            # Remove specific tags that might appear in the title part
+            tags_to_remove = [
+                r'[\.\s]UNRATED.*', r'[\.\s]Unrated.*', r'[\.\s]Uncut.*', r'[\.\s]UNCUT.*',
+                r'[\.\s]Directors[\.\s]Cut.*', r'[\.\s]Final[\.\s]Cut.*', r'[\.\s]DC.*',
+                r'[\.\s]REMASTERED.*', r'[\.\s]EXTENDED.*', r'[\.\s]Extended.*',
+                r'[\.\s]Theatrical.*', r'[\.\s]THEATRICAL.*'
+            ]
+
+            clean_title = extracted_title
+            for tag in tags_to_remove:
+                clean_title = re.sub(tag, "", clean_title, flags=re.IGNORECASE)
+
+            clean_title = clean_title.replace(".", " ").strip()
+            clean_title = re.sub(r'\s+', ' ', clean_title)  # Remove multiple spaces
+            clean_title = clean_title.replace(" ", "+")
+
+            return clean_title
+        except Exception as e:
+            debug(f"Error cleaning title '{title}': {e}")
+            return title
+
+
+def get_poster_link(shared_state, imdb_id):
+    imdb_metadata = get_imdb_metadata(imdb_id)
+    if imdb_metadata:
+        poster_link = imdb_metadata.get("poster_link")
+        if poster_link:
+            return poster_link
+
+    poster_link = None
+    if imdb_id:
+        poster_link = IMDbWeb.get_poster(imdb_id, shared_state.values["user_agent"])
+
+    if not poster_link:
+        debug(f"Could not get poster title for {imdb_id} from IMDb")
+
+    return poster_link
+
+
+def get_imdb_metadata(imdb_id):
+    db = _get_db("imdb_metadata")
+    now = datetime.now().timestamp()
+
+    # Try to load from DB
+    cached_metadata = None
+    try:
+        cached_data = db.retrieve(imdb_id)
+        if cached_data:
+            cached_metadata = loads(cached_data)
+            # If valid, update TTL and return
+            if cached_metadata.get("ttl") and cached_metadata["ttl"] > now:
+                cached_metadata["ttl"] = now + timedelta(days=30).total_seconds()
+                db.update_store(imdb_id, dumps(cached_metadata))
+                return cached_metadata
+    except Exception as e:
+        debug(f"Error retrieving IMDb metadata from DB for {imdb_id}: {e}")
+
+    # Initialize new metadata structure
+    imdb_metadata = {
+        "title": None,
+        "year": None,
+        "poster_link": None,
+        "localized": {},
+        "ttl": 0
+    }
+
+    # Fetch from API
+    response_json = IMDbAPI.get_title(imdb_id)
+
+    if not response_json:
+        # API failed. If we have stale cached data, return it as fallback
+        if cached_metadata:
+            debug(f"IMDb API failed for {imdb_id}, returning stale cached data.")
+            return cached_metadata
+        return imdb_metadata
+
+    # Process API response
+    imdb_metadata["title"] = TitleCleaner.sanitize(response_json.get("primaryTitle", ""))
+    imdb_metadata["year"] = response_json.get("startYear")
+    imdb_metadata["ttl"] = now + timedelta(days=30).total_seconds()
+
+    try:
+        imdb_metadata["poster_link"] = response_json.get("primaryImage").get("url")
+    except Exception as e:
+        debug(f"Could not find poster link for {imdb_id} from imdbapi.dev: {e}")
+        # Shorten TTL if data is incomplete
+        imdb_metadata["ttl"] = now + timedelta(days=1).total_seconds()
+
+    akas = IMDbAPI.get_akas(imdb_id)
+    if akas:
+        for aka in akas:
+            if aka.get("language"):
+                continue  # skip entries with specific language tags
+            if aka.get("country", {}).get("code", "").lower() == "de":
+                imdb_metadata["localized"]["de"] = TitleCleaner.sanitize(aka.get("text"))
+                break
+    else:
+        # Shorten TTL if AKAs failed
+        imdb_metadata["ttl"] = now + timedelta(days=1).total_seconds()
+
+    db.update_store(imdb_id, dumps(imdb_metadata))
+    return imdb_metadata
+
+
+def get_year(imdb_id):
+    imdb_metadata = get_imdb_metadata(imdb_id)
+    if imdb_metadata:
+        return imdb_metadata.get("year")
+    return None
+
+
+def get_localized_title(shared_state, imdb_id, language='de'):
+    imdb_metadata = get_imdb_metadata(imdb_id)
+    if imdb_metadata:
+        localized_title = imdb_metadata.get("localized").get(language)
+        if localized_title:
+            return localized_title
+        return imdb_metadata.get("title")
+
+    localized_title = IMDbWeb.get_localized_title(imdb_id, language, shared_state.values["user_agent"])
+
+    if not localized_title:
+        debug(f"Could not get localized title for {imdb_id} in {language} from IMDb")
+    else:
+        localized_title = TitleCleaner.sanitize(localized_title)
+    return localized_title
+
+
+def get_imdb_id_from_title(shared_state, title, language="de"):
+    imdb_id = None
+
+    if re.search(r"S\d{1,3}(E\d{1,3})?", title, re.IGNORECASE):
+        ttype_api = "TV_SERIES"
+        ttype_web = "tv"
+    else:
+        ttype_api = "MOVIE"
+        ttype_web = "ft"
+
+    title = TitleCleaner.clean(title)
+
+    # Check Search Cache (DB)
+    db = _get_db("imdb_searches")
+    try:
+        cached_data = db.retrieve(title)
+        if cached_data:
+            data = loads(cached_data)
+            # Check TTL (48 hours)
+            if data.get("timestamp") and datetime.fromtimestamp(data["timestamp"]) > datetime.now() - timedelta(
+                    hours=48):
+                return data.get("imdb_id")
+    except Exception as e:
+        debug(f"Error retrieving search cache for {title}: {e}")
+
+    # Try IMDbAPI.dev first
+    search_results = IMDbAPI.search_titles(title)
+    if search_results:
+        for result in search_results:
+            found_title = result.get("primaryTitle")
+            found_id = result.get("id")
+            found_type = result.get("type")
+
+            # Basic type filtering if possible from result data
+            if ttype_api == "TV_SERIES" and found_type not in ["tvSeries", "tvMiniSeries"]:
+                continue
+            if ttype_api == "MOVIE" and found_type not in ["movie", "tvMovie"]:
+                continue
+
+            if shared_state.search_string_in_sanitized_title(title, found_title):
+                imdb_id = found_id
+                break
+
+        # If no exact match found with type filtering, try relaxed matching
+        if not imdb_id:
+            for result in search_results:
+                found_title = result.get("primaryTitle")
+                found_id = result.get("id")
+                if shared_state.search_string_in_sanitized_title(title, found_title):
+                    imdb_id = found_id
+                    break
+
+    # Fallback to IMDb scraping if API failed or returned no results
+    if not imdb_id:
+        search_results = IMDbWeb.search_titles(title, ttype_web, language, shared_state.values["user_agent"])
+        if search_results:
+            for result in search_results:
+                try:
+                    found_title = result["listItem"]["titleText"]
+                    found_id = result["listItem"]["titleId"]
+                except KeyError:
+                    found_title = result["titleNameText"]
+                    found_id = result['id']
+
+                if shared_state.search_string_in_sanitized_title(title, found_title):
+                    imdb_id = found_id
+                    break
+
+    # Update Search Cache
+    try:
+        db.update_store(title, dumps({
+            "imdb_id": imdb_id,
+            "timestamp": datetime.now().timestamp()
+        }))
+    except Exception as e:
+        debug(f"Error updating search cache for {title}: {e}")
+
+    if not imdb_id:
+        debug(f"No IMDb-ID found for {title}")
+
+    return imdb_id

{quasarr-2.2.0 → quasarr-2.3.0}/quasarr/providers/version.py

@@ -8,7 +8,7 @@ import requests
 
 
 def get_version():
-    return "2.2.0"
+    return "2.3.0"
 
 
 def get_latest_version():

{quasarr-2.2.0 → quasarr-2.3.0}/quasarr/search/__init__.py

@@ -5,6 +5,7 @@
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
+from quasarr.providers.imdb_metadata import get_imdb_metadata
 from quasarr.providers.log import info, debug
 from quasarr.search.sources.al import al_feed, al_search
 from quasarr.search.sources.by import by_feed, by_search
@@ -31,6 +32,10 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
     if imdb_id and not imdb_id.startswith('tt'):
         imdb_id = f'tt{imdb_id}'
 
+    # Pre-populate IMDb metadata cache to avoid API hammering by search threads
+    if imdb_id:
+        get_imdb_metadata(imdb_id)
+
     docs_search = "lazylibrarian" in request_from.lower()
 
     al = shared_state.values["config"]("Hostnames").get("al")

{quasarr-2.2.0 → quasarr-2.3.0}/quasarr/search/sources/he.py

@@ -12,7 +12,7 @@ import requests
 from bs4 import BeautifulSoup
 
 from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
-from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.imdb_metadata import get_localized_title, get_year
 from quasarr.providers.log import info, debug
 
 hostname = "he"
@@ -84,6 +84,9 @@ def he_search(shared_state, start_time, request_from, search_string="", mirror=N
             if not local_title:
                 info(f"{hostname}: no title for IMDb {imdb_id}")
                 return releases
+            year = get_year(imdb_id)
+            if year:
+                local_title += f" {year}"
             source_search = local_title
         else:
             return releases
@@ -173,6 +176,9 @@ def he_search(shared_state, start_time, request_from, search_string="", mirror=N
             try:
                 r = requests.get(source, headers=headers, timeout=10)
                 soup = BeautifulSoup(r.content, 'html.parser')
+            except Exception as e:
+                mark_hostname_issue(hostname, search_type, str(e) if "e" in dir() else "Error occurred")
+            try:
                 imdb_link = soup.find('a', href=re.compile(r"imdb\.com/title/tt\d+", re.IGNORECASE))
                 if imdb_link:
                     release_imdb_id = re.search(r'tt\d+', imdb_link['href']).group()

{quasarr-2.2.0 → quasarr-2.3.0}/quasarr/search/sources/nk.py

@@ -13,7 +13,7 @@ import requests
 from bs4 import BeautifulSoup
 
 from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
-from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.imdb_metadata import get_localized_title, get_year
 from quasarr.providers.log import info, debug
 
 hostname = "nk"
@@ -75,6 +75,9 @@ def nk_search(shared_state, start_time, request_from, search_string="", mirror=N
             if not local_title:
                 info(f"{hostname}: no title for IMDb {imdb_id}")
                 return releases
+            year = get_year(imdb_id)
+            if year:
+                local_title += f" {year}"
             source_search = local_title
         else:
             return releases

{quasarr-2.2.0 → quasarr-2.3.0}/quasarr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quasarr
-Version: 2.2.0
+Version: 2.3.0
 Summary: Quasarr connects JDownloader with Radarr, Sonarr and LazyLibrarian. It also decrypts links protected by CAPTCHAs.
 Home-page: https://github.com/rix1337/Quasarr
 Author: rix1337

quasarr-2.2.0/quasarr/providers/imdb_metadata.py

@@ -1,142 +0,0 @@
-# -*- coding: utf-8 -*-
-# Quasarr
-# Project by https://github.com/rix1337
-
-import html
-import re
-from datetime import datetime, timedelta
-from json import loads
-from urllib.parse import quote
-
-import requests
-from bs4 import BeautifulSoup
-
-from quasarr.providers.log import info, debug
-
-
-def get_poster_link(shared_state, imdb_id):
-    poster_link = None
-    if imdb_id:
-        headers = {'User-Agent': shared_state.values["user_agent"]}
-        request = requests.get(f"https://www.imdb.com/title/{imdb_id}/", headers=headers, timeout=10).text
-        soup = BeautifulSoup(request, "html.parser")
-        try:
-            poster_set = soup.find('div', class_='ipc-poster').div.img[
-                "srcset"]  # contains links to posters in ascending resolution
-            poster_links = [x for x in poster_set.split(" ") if
-                            len(x) > 10]  # extract all poster links ignoring resolution info
-            poster_link = poster_links[-1]  # get the highest resolution poster
-        except:
-            pass
-
-    if not poster_link:
-        debug(f"Could not get poster title for {imdb_id} from IMDb")
-
-    return poster_link
-
-
-def get_localized_title(shared_state, imdb_id, language='de'):
-    localized_title = None
-
-    headers = {
-        'Accept-Language': language,
-        'User-Agent': shared_state.values["user_agent"]
-    }
-
-    try:
-        response = requests.get(f"https://www.imdb.com/title/{imdb_id}/", headers=headers, timeout=10)
-    except Exception as e:
-        info(f"Error loading IMDb metadata for {imdb_id}: {e}")
-        return localized_title
-
-    try:
-        match = re.findall(r'<title>(.*?) \(.*?</title>', response.text)
-        localized_title = match[0]
-    except:
-        try:
-            match = re.findall(r'<title>(.*?) - IMDb</title>', response.text)
-            localized_title = match[0]
-        except:
-            pass
-
-    if not localized_title:
-        debug(f"Could not get localized title for {imdb_id} in {language} from IMDb")
-
-    localized_title = html.unescape(localized_title)
-    localized_title = re.sub(r"[^a-zA-Z0-9äöüÄÖÜß&-']", ' ', localized_title).strip()
-    localized_title = localized_title.replace(" - ", "-")
-    localized_title = re.sub(r'\s{2,}', ' ', localized_title)
-
-    return localized_title
-
-
-def get_clean_title(title):
-    try:
-        extracted_title = re.findall(r"(.*?)(?:.(?!19|20)\d{2}|\.German|.GERMAN|\.\d{3,4}p|\.S(?:\d{1,3}))", title)[0]
-        leftover_tags_removed = re.sub(
-            r'(|.UNRATED.*|.Unrated.*|.Uncut.*|.UNCUT.*)(|.Directors.Cut.*|.Final.Cut.*|.DC.*|.REMASTERED.*|.EXTENDED.*|.Extended.*|.Theatrical.*|.THEATRICAL.*)',
-            "", extracted_title)
-        clean_title = leftover_tags_removed.replace(".", " ").strip().replace(" ", "+")
-
-    except:
-        clean_title = title
-    return clean_title
-
-
-def get_imdb_id_from_title(shared_state, title, language="de"):
-    imdb_id = None
-
-    if re.search(r"S\d{1,3}(E\d{1,3})?", title, re.IGNORECASE):
-        ttype = "tv"
-    else:
-        ttype = "ft"
-
-    title = get_clean_title(title)
-
-    threshold = 60 * 60 * 48  # 48 hours
-    context = "recents_imdb"
-    recently_searched = shared_state.get_recently_searched(shared_state, context, threshold)
-    if title in recently_searched:
-        title_item = recently_searched[title]
-        if title_item["timestamp"] > datetime.now() - timedelta(seconds=threshold):
-            return title_item["imdb_id"]
-
-    headers = {
-        'Accept-Language': language,
-        'User-Agent': shared_state.values["user_agent"]
-    }
-
-    results = requests.get(f"https://www.imdb.com/find/?q={quote(title)}&s=tt&ttype={ttype}&ref_=fn_{ttype}",
-                           headers=headers, timeout=10)
-
-    if results.status_code == 200:
-        soup = BeautifulSoup(results.text, "html.parser")
-        props = soup.find("script", text=re.compile("props"))
-        details = loads(props.string)
-        search_results = details['props']['pageProps']['titleResults']['results']
-
-        if len(search_results) > 0:
-            for result in search_results:
-                try:
-                    found_title = result["listItem"]["titleText"]
-                    found_id = result["listItem"]["titleId"]
-                except KeyError:
-                    found_title = result["titleNameText"]
-                    found_id = result['id']
-
-                if shared_state.search_string_in_sanitized_title(title, found_title):
-                    imdb_id = found_id
-                    break
-    else:
-        debug(f"Request on IMDb failed: {results.status_code}")
-
-    recently_searched[title] = {
-        "imdb_id": imdb_id,
-        "timestamp": datetime.now()
-    }
-    shared_state.update(context, recently_searched)
-
-    if not imdb_id:
-        debug(f"No IMDb-ID found for {title}")
-
-    return imdb_id