quasarr 2.3.0__py3-none-any.whl → 2.3.2__py3-none-any.whl

quasarr/__init__.py

@@ -169,6 +169,14 @@ def run():
                     else:
                         hostname_credentials_config(shared_state, site.upper(), hostname)
 
+        # Check FlareSolverr configuration
+        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)
+
         config = Config('JDownloader')
         user = config.get('user')
         password = config.get('password')
@@ -249,23 +257,33 @@ def flaresolverr_checker(shared_state_dict, shared_state_lock):
         flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
 
         flaresolverr_url = Config('FlareSolverr').get('url')
+        
+        # If FlareSolverr is not configured and not skipped, it means it's the first run
+        # and the user needs to be prompted via the WebUI.
+        # This background process should NOT block or prompt the user.
+        # It should only check and log the status.
         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')
+            info('FlareSolverr URL not configured. Please configure it via the WebUI.')
+            info('Some sites (AL) will not work without FlareSolverr.')
+            return # Exit the checker, it will be re-checked if user configures it later
 
         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}"')
+            info(f'Checking FlareSolverr at 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"]}"')
+                info(f'FlareSolverr connection successful. Using User-Agent: "{shared_state.values["user_agent"]}"')
+            else:
+                info('FlareSolverr check failed - using fallback user agent')
+                # Fallback user agent is already set in main process, but we log it
+                info(f'User Agent (fallback): "{FALLBACK_USER_AGENT}"')
 
     except KeyboardInterrupt:
         pass
+    except Exception as e:
+        info(f"An unexpected error occurred in FlareSolverr checker: {e}")
 
 
 def update_checker(shared_state_dict, shared_state_lock):

quasarr/api/config/__init__.py

@@ -288,8 +288,8 @@ def setup_config(app, shared_state):
                         "FlareSolverr URL saved successfully! A restart is recommended.")
                 else:
                     return render_fail(f"FlareSolverr returned unexpected status: {json_data.get('status')}")
-        except requests.RequestException as e:
-            return render_fail(f"Could not reach FlareSolverr: {str(e)}")
+        except requests.RequestException:
+            return render_fail(f"Could not reach FlareSolverr!")
 
         return render_fail("Could not reach FlareSolverr at that URL (expected HTTP 200).")
 

quasarr/providers/imdb_metadata.py

@@ -20,8 +20,57 @@ def _get_db(table_name):
     return DataBase(table_name)
 
 
+def _get_config(section):
+    """Lazy import to avoid circular dependency."""
+    from quasarr.storage.config import Config
+    return Config(section)
+
+
+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
+            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
+
+            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)
+            clean_title = clean_title.replace(" ", "+")
+
+            return clean_title
+        except Exception as e:
+            debug(f"Error cleaning title '{title}': {e}")
+            return title
+
+
 class IMDbAPI:
-    """Handles interactions with api.imdbapi.dev"""
+    """Tier 1: api.imdbapi.dev - Primary, fast, comprehensive."""
     BASE_URL = "https://api.imdbapi.dev"
 
     @staticmethod
@@ -31,7 +80,7 @@ class IMDbAPI:
             response.raise_for_status()
             return response.json()
         except Exception as e:
-            info(f"Error loading imdbapi.dev for {imdb_id}: {e}")
+            info(f"IMDbAPI get_title failed for {imdb_id}: {e}")
             return None
 
     @staticmethod
@@ -41,7 +90,7 @@ class IMDbAPI:
             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}")
+            info(f"IMDbAPI get_akas failed for {imdb_id}: {e}")
             return []
 
     @staticmethod
@@ -51,157 +100,348 @@ class IMDbAPI:
             response.raise_for_status()
             return response.json().get("titles", [])
         except Exception as e:
-            debug(f"Request on IMDbAPI failed: {e}")
+            debug(f"IMDbAPI search_titles failed: {e}")
             return []
 
 
-class IMDbWeb:
-    """Handles fallback interactions by scraping imdb.com"""
-    BASE_URL = "https://www.imdb.com"
+class IMDbCDN:
+    """Tier 2: v2.sg.media-imdb.com - Fast fallback for English data."""
+    CDN_URL = "https://v2.sg.media-imdb.com/suggestion"
 
     @staticmethod
-    def get_poster(imdb_id, user_agent):
-        headers = {'User-Agent': user_agent}
+    def _get_cdn_data(imdb_id, language, 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
+            if not imdb_id or len(imdb_id) < 2:
+                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)
+            headers = {
+                'Accept-Language': f'{language},en;q=0.9',
+                'User-Agent': user_agent,
+                'Accept': 'application/json'
+            }
+
+            first_char = imdb_id[0].lower()
+            url = f"{IMDbCDN.CDN_URL}/{first_char}/{imdb_id}.json"
+
+            response = requests.get(url, headers=headers, timeout=5)
             response.raise_for_status()
 
-            match = re.search(r'<title>(.*?) \(.*?</title>', response.text)
-            if not match:
-                match = re.search(r'<title>(.*?) - IMDb</title>', response.text)
+            data = response.json()
+
+            if "d" in data and len(data["d"]) > 0:
+                for entry in data["d"]:
+                    if entry.get("id") == imdb_id:
+                        return entry
+                return data["d"][0]
 
-            if match:
-                return match.group(1)
         except Exception as e:
-            info(f"Error loading IMDb metadata for {imdb_id}: {e}")
+            debug(f"IMDbCDN request failed for {imdb_id}: {e}")
+
+        return None
 
+    @staticmethod
+    def get_poster(imdb_id, user_agent):
+        data = IMDbCDN._get_cdn_data(imdb_id, 'en', user_agent)
+        if data:
+            image_node = data.get("i")
+            if image_node and "imageUrl" in image_node:
+                return image_node["imageUrl"]
+        return None
+
+    @staticmethod
+    def get_title(imdb_id, user_agent):
+        """Returns the English title from CDN."""
+        data = IMDbCDN._get_cdn_data(imdb_id, 'en', user_agent)
+        if data and "l" in data:
+            return data["l"]
         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)
+            clean_query = quote(query.lower().replace(" ", "_"))
+            if not clean_query: return []
+
+            headers = {
+                'Accept-Language': f'{language},en;q=0.9',
+                'User-Agent': user_agent
+            }
+
+            first_char = clean_query[0]
+            url = f"{IMDbCDN.CDN_URL}/{first_char}/{clean_query}.json"
+
+            response = requests.get(url, headers=headers, timeout=5)
+
+            if response.status_code == 200:
+                data = response.json()
+                results = []
+                if "d" in data:
+                    for item in data["d"]:
+                        results.append({
+                            'id': item.get('id'),
+                            'titleNameText': item.get('l'),
+                            'titleReleaseText': item.get('y')
+                        })
+                return results
 
-            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}")
+            from quasarr.providers.log import debug
+            debug(f"IMDb CDN search 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
+class IMDbFlareSolverr:
+    """Tier 3: FlareSolverr - Robust fallback using browser automation."""
+    WEB_URL = "https://www.imdb.com"
 
     @staticmethod
-    def clean(title):
+    def _request(url):
+        flaresolverr_url = _get_config('FlareSolverr').get('url')
+        flaresolverr_skipped = _get_db("skip_flaresolverr").retrieve("skipped")
+
+        if not flaresolverr_url or flaresolverr_skipped:
+            return None
+
         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
+            post_data = {
+                "cmd": "request.get",
+                "url": url,
+                "maxTimeout": 60000,
+            }
+
+            response = requests.post(flaresolverr_url, json=post_data, headers={"Content-Type": "application/json"},
+                                     timeout=60)
+            if response.status_code == 200:
+                json_response = response.json()
+                if json_response.get("status") == "ok":
+                    return json_response.get("solution", {}).get("response", "")
+        except Exception as e:
+            debug(f"FlareSolverr request failed for {url}: {e}")
 
-            # 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.*'
-            ]
+        return None
 
-            clean_title = extracted_title
-            for tag in tags_to_remove:
-                clean_title = re.sub(tag, "", clean_title, flags=re.IGNORECASE)
+    @staticmethod
+    def get_poster(imdb_id):
+        html_content = IMDbFlareSolverr._request(f"{IMDbFlareSolverr.WEB_URL}/title/{imdb_id}/")
+        if html_content:
+            try:
+                soup = BeautifulSoup(html_content, "html.parser")
+                poster_div = soup.find('div', class_='ipc-poster')
+                if poster_div and poster_div.div and poster_div.div.img:
+                    poster_set = poster_div.div.img.get("srcset")
+                    if poster_set:
+                        poster_links = [x for x in poster_set.split(" ") if len(x) > 10]
+                        return poster_links[-1]
+            except Exception as e:
+                debug(f"FlareSolverr poster parsing failed: {e}")
+        return None
 
-            clean_title = clean_title.replace(".", " ").strip()
-            clean_title = re.sub(r'\s+', ' ', clean_title)  # Remove multiple spaces
-            clean_title = clean_title.replace(" ", "+")
+    @staticmethod
+    def get_localized_title(imdb_id, language):
+        # FlareSolverr doesn't reliably support headers for localization.
+        # Instead, we scrape the release info page which lists AKAs.
+        url = f"{IMDbFlareSolverr.WEB_URL}/title/{imdb_id}/releaseinfo"
+        html_content = IMDbFlareSolverr._request(url)
+
+        if html_content:
+            try:
+                soup = BeautifulSoup(html_content, "html.parser")
+
+                # Map language codes to country names commonly used in IMDb AKAs
+                country_map = {
+                    'de': ['Germany', 'Austria', 'Switzerland', 'West Germany'],
+                    'fr': ['France', 'Canada', 'Belgium'],
+                    'es': ['Spain', 'Mexico', 'Argentina'],
+                    'it': ['Italy'],
+                    'pt': ['Portugal', 'Brazil'],
+                    'ru': ['Russia', 'Soviet Union'],
+                    'ja': ['Japan'],
+                    'hi': ['India']
+                }
+
+                target_countries = country_map.get(language, [])
+
+                # Find the AKAs list
+                # The structure is a list of items with country names and titles
+                items = soup.find_all("li", class_="ipc-metadata-list__item")
+
+                for item in items:
+                    label_span = item.find("span", class_="ipc-metadata-list-item__label")
+                    if not label_span:
+                        # Sometimes it's an anchor if it's a link
+                        label_span = item.find("a", class_="ipc-metadata-list-item__label")
+
+                    if label_span:
+                        country = label_span.get_text(strip=True)
+                        # Check if this country matches our target language
+                        if any(c in country for c in target_countries):
+                            # Found a matching country, get the title
+                            title_span = item.find("span", class_="ipc-metadata-list-item__list-content-item")
+                            if title_span:
+                                return title_span.get_text(strip=True)
+
+            except Exception as e:
+                debug(f"FlareSolverr localized title parsing failed: {e}")
 
-            return clean_title
-        except Exception as e:
-            debug(f"Error cleaning title '{title}': {e}")
-            return title
+        return None
+
+    @staticmethod
+    def search_titles(query, ttype):
+        url = f"{IMDbFlareSolverr.WEB_URL}/find/?q={quote(query)}&s=tt&ttype={ttype}&ref_=fn_{ttype}"
+        html_content = IMDbFlareSolverr._request(url)
+
+        if html_content:
+            try:
+                soup = BeautifulSoup(html_content, "html.parser")
+                props = soup.find("script", text=re.compile("props"))
+                if props:
+                    details = loads(props.string)
+                    results = details['props']['pageProps']['titleResults']['results']
+                    mapped_results = []
+                    for result in results:
+                        try:
+                            mapped_results.append({
+                                'id': result["listItem"]["titleId"],
+                                'titleNameText': result["listItem"]["titleText"],
+                                'titleReleaseText': result["listItem"].get("releaseYear")
+                            })
+                        except KeyError:
+                            mapped_results.append({
+                                'id': result.get('id'),
+                                'titleNameText': result.get("titleNameText"),
+                                'titleReleaseText': result.get("titleReleaseText")
+                            })
+                    return mapped_results
+
+                results = []
+                items = soup.find_all("li", class_="ipc-metadata-list-summary-item")
+                for item in items:
+                    a_tag = item.find("a", class_="ipc-metadata-list-summary-item__t")
+                    if a_tag:
+                        href = a_tag.get("href", "")
+                        id_match = re.search(r"(tt\d+)", href)
+                        if id_match:
+                            results.append({
+                                'id': id_match.group(1),
+                                'titleNameText': a_tag.get_text(strip=True),
+                                'titleReleaseText': ""
+                            })
+                return results
+
+            except Exception as e:
+                debug(f"FlareSolverr search parsing failed: {e}")
+        return []
+
+
+# =============================================================================
+# Main Functions (Chain of Responsibility)
+# =============================================================================
+
+def _update_cache(imdb_id, key, value, language=None):
+    db = _get_db("imdb_metadata")
+    try:
+        cached_data = db.retrieve(imdb_id)
+        if cached_data:
+            metadata = loads(cached_data)
+        else:
+            metadata = {
+                "title": None,
+                "year": None,
+                "poster_link": None,
+                "localized": {},
+                "ttl": 0
+            }
+
+        if key == "localized" and language:
+            if "localized" not in metadata or not isinstance(metadata["localized"], dict):
+                metadata["localized"] = {}
+            metadata["localized"][language] = value
+        else:
+            metadata[key] = value
+
+        now = datetime.now().timestamp()
+        days = 7 if metadata.get("title") and metadata.get("year") else 1
+        metadata["ttl"] = now + timedelta(days=days).total_seconds()
+
+        db.update_store(imdb_id, dumps(metadata))
+    except Exception as e:
+        debug(f"Error updating IMDb metadata cache for {imdb_id}: {e}")
 
 
 def get_poster_link(shared_state, imdb_id):
+    # 0. Check Cache (via get_imdb_metadata)
     imdb_metadata = get_imdb_metadata(imdb_id)
-    if imdb_metadata:
-        poster_link = imdb_metadata.get("poster_link")
-        if poster_link:
-            return poster_link
+    if imdb_metadata and imdb_metadata.get("poster_link"):
+        return imdb_metadata.get("poster_link")
 
-    poster_link = None
-    if imdb_id:
-        poster_link = IMDbWeb.get_poster(imdb_id, shared_state.values["user_agent"])
+    user_agent = shared_state.values["user_agent"]
 
-    if not poster_link:
-        debug(f"Could not get poster title for {imdb_id} from IMDb")
+    poster = IMDbCDN.get_poster(imdb_id, user_agent)
+    if poster:
+        _update_cache(imdb_id, "poster_link", poster)
+        return poster
 
-    return poster_link
+    poster = IMDbFlareSolverr.get_poster(imdb_id)
+    if poster:
+        _update_cache(imdb_id, "poster_link", poster)
+        return poster
+
+    debug(f"Could not get poster title for {imdb_id}")
+    return None
+
+
+def get_localized_title(shared_state, imdb_id, language='de'):
+    # 0. Check Cache (via get_imdb_metadata)
+    imdb_metadata = get_imdb_metadata(imdb_id)
+    if imdb_metadata:
+        localized = imdb_metadata.get("localized", {}).get(language)
+        if localized: return localized
+        if language == 'en' and imdb_metadata.get("title"):
+            return imdb_metadata.get("title")
+
+    user_agent = shared_state.values["user_agent"]
+
+    if language == 'en':
+        title = IMDbCDN.get_title(imdb_id, user_agent)
+        if title:
+            sanitized_title = TitleCleaner.sanitize(title)
+            _update_cache(imdb_id, "title", sanitized_title)
+            return sanitized_title
+
+    title = IMDbFlareSolverr.get_localized_title(imdb_id, language)
+    if title:
+        sanitized_title = TitleCleaner.sanitize(title)
+        _update_cache(imdb_id, "localized", sanitized_title, language)
+        return sanitized_title
+
+    # Final fallback: Try CDN for English title if localization failed
+    title = IMDbCDN.get_title(imdb_id, user_agent)
+    if title:
+        sanitized_title = TitleCleaner.sanitize(title)
+        _update_cache(imdb_id, "title", sanitized_title)
+        return sanitized_title
+
+    debug(f"Could not get localized title for {imdb_id} in {language}")
+    return None
 
 
 def get_imdb_metadata(imdb_id):
     db = _get_db("imdb_metadata")
     now = datetime.now().timestamp()
-
-    # Try to load from DB
     cached_metadata = None
+
+    # 0. Check Cache
     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}")
+        cached_metadata = None
 
-    # Initialize new metadata structure
     imdb_metadata = {
         "title": None,
         "year": None,
@@ -210,66 +450,44 @@ def get_imdb_metadata(imdb_id):
         "ttl": 0
     }
 
-    # Fetch from API
+    # 1. Try 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()
+    if response_json:
+        imdb_metadata["title"] = TitleCleaner.sanitize(response_json.get("primaryTitle", ""))
+        imdb_metadata["year"] = response_json.get("startYear")
+        
+        days = 7 if imdb_metadata.get("title") and imdb_metadata.get("year") else 1
+        imdb_metadata["ttl"] = now + timedelta(days=days).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
+        try:
+            imdb_metadata["poster_link"] = response_json.get("primaryImage").get("url")
+        except:
+            pass
+
+        akas = IMDbAPI.get_akas(imdb_id)
+        if akas:
+            for aka in akas:
+                if aka.get("language"): continue
+                if aka.get("country", {}).get("code", "").lower() == "de":
+                    imdb_metadata["localized"]["de"] = TitleCleaner.sanitize(aka.get("text"))
+                    break
 
+        db.update_store(imdb_id, dumps(imdb_metadata))
+        return imdb_metadata
 
-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")
+    # API Failed. If we have stale cache, return it.
+    if cached_metadata:
+        return cached_metadata
 
-    localized_title = IMDbWeb.get_localized_title(imdb_id, language, shared_state.values["user_agent"])
+    # 2. Fallback: Try CDN for basic info (English title, Year, Poster)
+    # We can't get localized titles from CDN, but we can get the rest.
+    # We need a user agent, but this function doesn't receive shared_state.
+    # We'll skip CDN fallback here to avoid circular deps or complexity, 
+    # as get_poster_link and get_localized_title handle their own fallbacks.
+    # But to populate the DB, we could try. For now, return empty/partial if API fails.
 
-    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
+    return imdb_metadata
 
 
 def get_imdb_id_from_title(shared_state, title, language="de"):
@@ -284,72 +502,76 @@ def get_imdb_id_from_title(shared_state, title, language="de"):
 
     title = TitleCleaner.clean(title)
 
-    # Check Search Cache (DB)
+    # 0. Check Search Cache
     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}")
+    except Exception:
+        pass
 
-    # Try IMDbAPI.dev first
+    user_agent = shared_state.values["user_agent"]
+
+    # 1. Try API
     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")
+        imdb_id = _match_result(shared_state, title, search_results, ttype_api, is_api=True)
 
-            # 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
+    # 2. Try CDN (Fallback)
+    if not imdb_id:
+        search_results = IMDbCDN.search_titles(title, ttype_web, language, user_agent)
+        if search_results:
+            imdb_id = _match_result(shared_state, title, search_results, ttype_api, is_api=False)
 
-    # Fallback to IMDb scraping if API failed or returned no results
+    # 3. Try FlareSolverr (Last Resort)
     if not imdb_id:
-        search_results = IMDbWeb.search_titles(title, ttype_web, language, shared_state.values["user_agent"])
+        search_results = IMDbFlareSolverr.search_titles(title, ttype_web)
         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
+            imdb_id = _match_result(shared_state, title, search_results, ttype_api, is_api=False)
 
-    # Update Search Cache
+    # Update 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}")
+    except Exception:
+        pass
 
     if not imdb_id:
         debug(f"No IMDb-ID found for {title}")
 
     return imdb_id
+
+
+def _match_result(shared_state, title, results, ttype_api, is_api=False):
+    for result in results:
+        found_title = result.get("primaryTitle") if is_api else result.get("titleNameText")
+        found_id = result.get("id")
+
+        if is_api:
+            found_type = result.get("type")
+            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):
+            return found_id
+
+    for result in results:
+        found_title = result.get("primaryTitle") if is_api else result.get("titleNameText")
+        found_id = result.get("id")
+        if shared_state.search_string_in_sanitized_title(title, found_title):
+            return found_id
+
+    return None
+
+
+def get_year(imdb_id):
+    imdb_metadata = get_imdb_metadata(imdb_id)
+    if imdb_metadata:
+        return imdb_metadata.get("year")
+    return None

quasarr/providers/version.py

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

quasarr/search/sources/he.py

@@ -84,9 +84,10 @@ 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}"
+            if not season: 
+                year = get_year(imdb_id)
+                if year:
+                    local_title += f" {year}"
             source_search = local_title
         else:
             return releases
@@ -104,8 +105,8 @@ def he_search(shared_state, start_time, request_from, search_string="", mirror=N
     if season:
         source_search += f" S{int(season):02d}"
 
-    if episode:
-        source_search += f"E{int(episode):02d}"
+        if episode:
+            source_search += f"E{int(episode):02d}"
 
     url = f'https://{host}/tag/{tag}/'
 

quasarr/search/sources/nk.py

@@ -75,9 +75,10 @@ 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}"
+            if not season:
+                year = get_year(imdb_id)
+                if year:
+                    local_title += f" {year}"
             source_search = local_title
         else:
             return releases
@@ -95,8 +96,8 @@ def nk_search(shared_state, start_time, request_from, search_string="", mirror=N
     if season:
         source_search += f" S{int(season):02d}"
 
-    if episode:
-        source_search += f"E{int(episode):02d}"
+        if episode:
+            source_search += f"E{int(episode):02d}"
 
     url = f'https://{host}/search'
     headers = {"User-Agent": shared_state.values["user_agent"]}

{quasarr-2.3.0.dist-info → quasarr-2.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quasarr
-Version: 2.3.0
+Version: 2.3.2
 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.3.0.dist-info → quasarr-2.3.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
-quasarr/__init__.py,sha256=eGJ6-vv6yQBq04TyeZ2j7EW0i-UW21Khbqoj5JJktoo,14759
+quasarr/__init__.py,sha256=QRu_dlfLdToYkeO96bHaA8Kp0GmSL0IZc9ceRSxKWS0,15766
 quasarr/api/__init__.py,sha256=KLnFSe5l3MrVgrbu6-7GlE2PqouVyizqiRZfQkBtge0,19587
 quasarr/api/arr/__init__.py,sha256=eEop8A5t936uT5azn4qz0bq1DMX84_Ja16wyleGFhyM,18495
 quasarr/api/captcha/__init__.py,sha256=Mqg2HhWMaUc07cVaEYHAbf-YvnxkiYVbkWT-g92J-2k,72960
-quasarr/api/config/__init__.py,sha256=kIGCHtKTUovOHe9xMEdz-6_psCmx6aFoyrTP-jJah0s,14187
+quasarr/api/config/__init__.py,sha256=q-7vK5YULrSDgTicho--bNK8aAhcbzCdhhNwEwUEwWg,14173
 quasarr/api/packages/__init__.py,sha256=ox0vzuXByag49RUEwYPWtMacsXl_iksvubHgDmG5RWQ,25192
 quasarr/api/sponsors_helper/__init__.py,sha256=vZIFGkc5HTRozjvi47tqxz6XpwDe8sDXVyeydc9k0Y0,6708
 quasarr/api/statistics/__init__.py,sha256=0Os2rbqQ8ZN3R0XAavGVHlacKsAjp7GYjEIJCwvnsl8,7063
@@ -35,7 +35,7 @@ quasarr/providers/cloudflare.py,sha256=oUDR7OQ8E-8vCtagZLnIS2ZZV3ERffhxmW0njKKbt
 quasarr/providers/hostname_issues.py,sha256=9PJFIosLB-bMTmgWlR5-sYAmcyps7TDoSYjoL9cw9TE,1460
 quasarr/providers/html_images.py,sha256=rrovPNl-FTTKKA-4HCPEhsYpq5b20VDrsB7t4RrQf3w,15531
 quasarr/providers/html_templates.py,sha256=IGWwt78bP2oJx4VzOP6w9zp7KVXgDY6Qz5ySL9cLGWI,15815
-quasarr/providers/imdb_metadata.py,sha256=Rq43t1-uFEYZ8Iq197I6FZjYwDkSuymIjEYxWwlbfmE,12572
+quasarr/providers/imdb_metadata.py,sha256=a_kn9lw5cj5ZbxtrRBQKyF78ctMgHJJTW0DF2DONWOY,20771
 quasarr/providers/jd_cache.py,sha256=mSvMrs3UwTn3sd9yGSJKGT-qwYeyYKC_l8whpXTVn7s,13530
 quasarr/providers/log.py,sha256=_g5RwtfuksARXnvryhsngzoJyFcNzj6suqd3ndqZM0Y,313
 quasarr/providers/myjd_api.py,sha256=Z3PEiO3c3UfDSr4Up5rgwTAnjloWHb-H1RkJ6BLKZv8,34140
@@ -44,7 +44,7 @@ quasarr/providers/obfuscated.py,sha256=EYm_7SfdJd9ae_m4HZgY9ruDXC5J9hb4KEV_WAnk-
 quasarr/providers/shared_state.py,sha256=5a_ZbGqTvt4-OqBt2a1WtR9I5J_Ky7IlkEY8EGtKVu8,30646
 quasarr/providers/statistics.py,sha256=cEQixYnDMDqtm5wWe40E_2ucyo4mD0n3SrfelhQi1L8,6452
 quasarr/providers/utils.py,sha256=mcUPbcXMsLmrYv0CTZO5a9aOt2-JLyL3SZxu6N8OyjU,12075
-quasarr/providers/version.py,sha256=yMqY-dgXR5J5LGPMOg1B63SCVU62c-fsK76fQMP1cYo,4003
+quasarr/providers/version.py,sha256=SOiiYu52mdnbNCFK5iCGtzvQ0XMh6AbCbN3NFCotiF8,4003
 quasarr/providers/web_server.py,sha256=AYd0KRxdDWMBr87BP8wlSMuL4zZo0I_rY-vHBai6Pfg,1688
 quasarr/providers/sessions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 quasarr/providers/sessions/al.py,sha256=AQ59vVU7uQSuwZLNppNsZAFvpow3zcxQ29dirPbyYc4,13432
@@ -61,9 +61,9 @@ quasarr/search/sources/dl.py,sha256=L4GK58Mp46dAZzmwtMB4ia1w0SSpp3z3eFvrmT-5278,
 quasarr/search/sources/dt.py,sha256=hvOqPKQRw5joSaTb9mpdPZXL4xpU167SFmLg8yhsPwM,10227
 quasarr/search/sources/dw.py,sha256=hna1ueKjdi9uqRQJ7UPenT0ym7igQgWGrv_--yGChVs,8215
 quasarr/search/sources/fx.py,sha256=xZUrv7dJSSmeLR2xnRQsRZAk9Q0-fDfQLNjz4wdBTqo,9452
-quasarr/search/sources/he.py,sha256=eBzOtJRNpJuc7YQmMFMMQ7SLp81sLwA3Jdk_fKYPNRE,7330
+quasarr/search/sources/he.py,sha256=LZM5JquDdocTpqRUS7ObYEwEGo5pyJWOvZ91GCp7YJ8,7378
 quasarr/search/sources/mb.py,sha256=Hq1zupo27FzYSQUio03HPG0wP4jYwOXl6cqgdOpjlzQ,8178
-quasarr/search/sources/nk.py,sha256=MZXW6QK78-NBzoHf-bw3B_-TwpGkbyVSOd9bHT2qISo,7099
+quasarr/search/sources/nk.py,sha256=Y-FgWmKyiPqcTdDsAGviClL_wyip7zPDNwrSPCcx4Ew,7146
 quasarr/search/sources/nx.py,sha256=UXUSYEL4zwYVwCri359I26GYN8CDuCKokpOOR21YEns,7602
 quasarr/search/sources/sf.py,sha256=9k9K8_tYVarpW8n20HA2qAplBL14mIQCsorJO-ZxN6g,15811
 quasarr/search/sources/sj.py,sha256=LW2dVDfZ90mDdrQ6ZYtXb0eOjV3cCh6kEW7lTra1c5M,7608
@@ -74,9 +74,9 @@ quasarr/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 quasarr/storage/config.py,sha256=SSTgIce2FVYoVTK_6OCU3msknhxuLA3EC4Kcrrf_dxQ,6378
 quasarr/storage/setup.py,sha256=Cbo0phZbC6JP2wx_qER3vpaLSTDLbKEfdXj6KoAMkWw,47403
 quasarr/storage/sqlite_database.py,sha256=yMqFQfKf0k7YS-6Z3_7pj4z1GwWSXJ8uvF4IydXsuTE,3554
-quasarr-2.3.0.dist-info/licenses/LICENSE,sha256=QQFCAfDgt7lSA8oSWDHIZ9aTjFbZaBJdjnGOHkuhK7k,1060
-quasarr-2.3.0.dist-info/METADATA,sha256=ZmpqDWmp3YiLqw7huxVjmGCkUIvdPxSdyQ29icEe9bY,15024
-quasarr-2.3.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-quasarr-2.3.0.dist-info/entry_points.txt,sha256=gXi8mUKsIqKVvn-bOc8E5f04sK_KoMCC-ty6b2Hf-jc,40
-quasarr-2.3.0.dist-info/top_level.txt,sha256=dipJdaRda5ruTZkoGfZU60bY4l9dtPlmOWwxK_oGSF0,8
-quasarr-2.3.0.dist-info/RECORD,,
+quasarr-2.3.2.dist-info/licenses/LICENSE,sha256=QQFCAfDgt7lSA8oSWDHIZ9aTjFbZaBJdjnGOHkuhK7k,1060
+quasarr-2.3.2.dist-info/METADATA,sha256=iF4XkBvoRySRgnKxa57ezN0mvvpKs0F8V6Qr3hEjgFA,15024
+quasarr-2.3.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+quasarr-2.3.2.dist-info/entry_points.txt,sha256=gXi8mUKsIqKVvn-bOc8E5f04sK_KoMCC-ty6b2Hf-jc,40
+quasarr-2.3.2.dist-info/top_level.txt,sha256=dipJdaRda5ruTZkoGfZU60bY4l9dtPlmOWwxK_oGSF0,8
+quasarr-2.3.2.dist-info/RECORD,,