quasarr 2.4.7__py3-none-any.whl → 2.4.9__py3-none-any.whl

quasarr/search/sources/al.py

@@ -5,16 +5,19 @@
 import time
 from base64 import urlsafe_b64encode
 from html import unescape
-from urllib.parse import urljoin, quote_plus
+from urllib.parse import quote_plus, urljoin
 
 from bs4 import BeautifulSoup
 
-from quasarr.downloads.sources.al import (guess_title,
-                                          parse_info_from_feed_entry, parse_info_from_download_item)
-from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
+from quasarr.downloads.sources.al import (
+    guess_title,
+    parse_info_from_download_item,
+    parse_info_from_feed_entry,
+)
+from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
 from quasarr.providers.imdb_metadata import get_localized_title
-from quasarr.providers.log import info, debug
-from quasarr.providers.sessions.al import invalidate_session, fetch_via_requests_session
+from quasarr.providers.log import debug, info
+from quasarr.providers.sessions.al import fetch_via_requests_session, invalidate_session
 
 hostname = "al"
 supported_mirrors = ["rapidgator", "ddownload"]
@@ -77,7 +80,7 @@ def parse_relative_date(raw: str) -> datetime | None:
         unit = english_match.group(2).lower()
 
         # Remove plural 's' if present
-        if unit.endswith('s'):
+        if unit.endswith("s"):
             unit = unit[:-1]
 
         if unit.startswith("second"):
@@ -124,7 +127,9 @@ def al_feed(shared_state, start_time, request_from, mirror=None):
     host = shared_state.values["config"]("Hostnames").get(hostname)
 
     if not "arr" in request_from.lower():
-        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        debug(
+            f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!'
+        )
         return releases
 
     if "Radarr" in request_from:
@@ -137,15 +142,19 @@ def al_feed(shared_state, start_time, request_from, mirror=None):
         return releases
 
     try:
-        r = fetch_via_requests_session(shared_state, method="GET", target_url=f'https://www.{host}/', timeout=30)
+        r = fetch_via_requests_session(
+            shared_state, method="GET", target_url=f"https://www.{host}/", timeout=30
+        )
         r.raise_for_status()
     except Exception as e:
         info(f"{hostname}: could not fetch feed: {e}")
-        mark_hostname_issue(hostname, "feed", str(e) if "e" in dir() else "Error occurred")
+        mark_hostname_issue(
+            hostname, "feed", str(e) if "e" in dir() else "Error occurred"
+        )
         invalidate_session(shared_state)
         return releases
 
-    soup = BeautifulSoup(r.content, 'html.parser')
+    soup = BeautifulSoup(r.content, "html.parser")
 
     # 1) New “Releases”
     release_rows = soup.select("#releases_updates_list table tbody tr")
@@ -205,34 +214,42 @@ def al_feed(shared_state, start_time, request_from, mirror=None):
             mt_blocks = tr.find_all("div", class_="mt10")
             for block in mt_blocks:
                 release_id = get_release_id(block)
-                release_info = parse_info_from_feed_entry(block, raw_base_title, release_type)
+                release_info = parse_info_from_feed_entry(
+                    block, raw_base_title, release_type
+                )
                 final_title = guess_title(shared_state, raw_base_title, release_info)
 
                 # Build payload using final_title
                 mb = 0  # size not available in feed
-                raw = f"{final_title}|{url}|{mirror}|{mb}|{release_id}||{hostname}".encode("utf-8")
+                raw = f"{final_title}|{url}|{mirror}|{mb}|{release_id}||{hostname}".encode(
+                    "utf-8"
+                )
                 payload = urlsafe_b64encode(raw).decode("utf-8")
                 link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
 
                 # Append only unique releases
                 if final_title not in [r["details"]["title"] for r in releases]:
-                    releases.append({
-                        "details": {
-                            "title": final_title,
-                            "hostname": hostname,
-                            "imdb_id": None,
-                            "link": link,
-                            "mirror": mirror,
-                            "size": mb * 1024 * 1024,
-                            "date": date_converted,
-                            "source": url
-                        },
-                        "type": "protected"
-                    })
+                    releases.append(
+                        {
+                            "details": {
+                                "title": final_title,
+                                "hostname": hostname,
+                                "imdb_id": None,
+                                "link": link,
+                                "mirror": mirror,
+                                "size": mb * 1024 * 1024,
+                                "date": date_converted,
+                                "source": url,
+                            },
+                            "type": "protected",
+                        }
+                    )
 
         except Exception as e:
             info(f"{hostname}: error parsing feed item: {e}")
-            mark_hostname_issue(hostname, "feed", str(e) if "e" in dir() else "Error occurred")
+            mark_hostname_issue(
+                hostname, "feed", str(e) if "e" in dir() else "Error occurred"
+            )
 
     elapsed = time.time() - start_time
     debug(f"Time taken: {elapsed:.2f}s ({hostname})")
@@ -243,19 +260,28 @@ def al_feed(shared_state, start_time, request_from, mirror=None):
 
 
 def extract_season(title: str) -> int | None:
-    match = re.search(r'(?i)(?:^|[^a-zA-Z0-9])S(\d{1,4})(?!\d)', title)
+    match = re.search(r"(?i)(?:^|[^a-zA-Z0-9])S(\d{1,4})(?!\d)", title)
     if match:
         return int(match.group(1))
     return None
 
 
-def al_search(shared_state, start_time, request_from, search_string,
-              mirror=None, season=None, episode=None):
+def al_search(
+    shared_state,
+    start_time,
+    request_from,
+    search_string,
+    mirror=None,
+    season=None,
+    episode=None,
+):
     releases = []
     host = shared_state.values["config"]("Hostnames").get(hostname)
 
     if not "arr" in request_from.lower():
-        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        debug(
+            f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!'
+        )
         return releases
 
     if "Radarr" in request_from:
@@ -269,7 +295,7 @@ def al_search(shared_state, start_time, request_from, search_string,
 
     imdb_id = shared_state.is_imdb_id(search_string)
     if imdb_id:
-        title = get_localized_title(shared_state, imdb_id, 'de')
+        title = get_localized_title(shared_state, imdb_id, "de")
         if not title:
             info(f"{hostname}: no title for IMDb {imdb_id}")
             return releases
@@ -280,21 +306,29 @@ def al_search(shared_state, start_time, request_from, search_string,
     encoded_search_string = quote_plus(search_string)
 
     try:
-        url = f'https://www.{host}/search?q={encoded_search_string}'
-        r = fetch_via_requests_session(shared_state, method="GET", target_url=url, timeout=10)
+        url = f"https://www.{host}/search?q={encoded_search_string}"
+        r = fetch_via_requests_session(
+            shared_state, method="GET", target_url=url, timeout=10
+        )
         r.raise_for_status()
     except Exception as e:
         info(f"{hostname}: search load error: {e}")
-        mark_hostname_issue(hostname, "search", str(e) if "e" in dir() else "Error occurred")
+        mark_hostname_issue(
+            hostname, "search", str(e) if "e" in dir() else "Error occurred"
+        )
         invalidate_session(shared_state)
         return releases
 
     if r.history:
         # If just one valid search result exists, AL skips the search result page
         last_redirect = r.history[-1]
-        redirect_location = last_redirect.headers['Location']
-        absolute_redirect_url = urljoin(last_redirect.url, redirect_location)  # in case of relative URL
-        debug(f"{search_string} redirected to {absolute_redirect_url} instead of search results page")
+        redirect_location = last_redirect.headers["Location"]
+        absolute_redirect_url = urljoin(
+            last_redirect.url, redirect_location
+        )  # in case of relative URL
+        debug(
+            f"{search_string} redirected to {absolute_redirect_url} instead of search results page"
+        )
 
         try:
             soup = BeautifulSoup(r.text, "html.parser")
@@ -304,18 +338,18 @@ def al_search(shared_state, start_time, request_from, search_string,
 
         results = [{"url": absolute_redirect_url, "title": page_title}]
     else:
-        soup = BeautifulSoup(r.text, 'html.parser')
+        soup = BeautifulSoup(r.text, "html.parser")
         results = []
 
-        for panel in soup.select('div.panel.panel-default'):
-            body = panel.find('div', class_='panel-body')
+        for panel in soup.select("div.panel.panel-default"):
+            body = panel.find("div", class_="panel-body")
             if not body:
                 continue
 
-            title_tag = body.select_one('h4.title-list a[href]')
+            title_tag = body.select_one("h4.title-list a[href]")
             if not title_tag:
                 continue
-            url = title_tag['href'].strip()
+            url = title_tag["href"].strip()
             name = title_tag.get_text(strip=True)
 
             sanitized_search_string = shared_state.sanitize_string(search_string)
@@ -326,13 +360,13 @@ def al_search(shared_state, start_time, request_from, search_string,
             debug(f"Matched search string '{search_string}' with result '{name}'")
 
             type_label = None
-            for lbl in body.select('div.label-group a[href]'):
-                href = lbl['href']
-                if '/anime-series' in href:
-                    type_label = 'series'
+            for lbl in body.select("div.label-group a[href]"):
+                href = lbl["href"]
+                if "/anime-series" in href:
+                    type_label = "series"
                     break
-                if '/anime-movies' in href:
-                    type_label = 'movie'
+                if "/anime-movies" in href:
+                    type_label = "movie"
                     break
 
             if not type_label or type_label != valid_type:
@@ -347,7 +381,9 @@ def al_search(shared_state, start_time, request_from, search_string,
 
             context = "recents_al"
             threshold = 60
-            recently_searched = shared_state.get_recently_searched(shared_state, context, threshold)
+            recently_searched = shared_state.get_recently_searched(
+                shared_state, context, threshold
+            )
             entry = recently_searched.get(url, {})
             ts = entry.get("timestamp")
             use_cache = ts and ts > datetime.now() - timedelta(seconds=threshold)
@@ -357,7 +393,9 @@ def al_search(shared_state, start_time, request_from, search_string,
                 data_html = entry["html"]
             else:
                 entry = {"timestamp": datetime.now()}
-                data_html = fetch_via_requests_session(shared_state, method="GET", target_url=url, timeout=10).text
+                data_html = fetch_via_requests_session(
+                    shared_state, method="GET", target_url=url, timeout=10
+                ).text
 
             entry["html"] = data_html
             recently_searched[url] = entry
@@ -371,8 +409,13 @@ def al_search(shared_state, start_time, request_from, search_string,
             for tab in download_tabs:
                 release_id += 1
 
-                release_info = parse_info_from_download_item(tab, content, page_title=title,
-                                                             release_type=valid_type, requested_episode=episode)
+                release_info = parse_info_from_download_item(
+                    tab,
+                    content,
+                    page_title=title,
+                    release_type=valid_type,
+                    requested_episode=episode,
+                )
 
                 # Parse date
                 date_td = tab.select_one("tr:has(th>i.fa-calendar-alt) td.modified")
@@ -384,15 +427,16 @@ def al_search(shared_state, start_time, request_from, search_string,
                     except Exception:
                         date_str = ""
                 else:
-                    date_str = (datetime.utcnow() - timedelta(hours=1)) \
-                        .strftime("%a, %d %b %Y %H:%M:%S +0000")
+                    date_str = (datetime.utcnow() - timedelta(hours=1)).strftime(
+                        "%a, %d %b %Y %H:%M:%S +0000"
+                    )
 
                 # Parse filesize from the <tr> with <i class="fa-hdd">
                 size_td = tab.select_one("tr:has(th>i.fa-hdd) td")
                 mb = 0
                 if size_td:
                     size_text = size_td.get_text(strip=True)
-                    candidates = re.findall(r'(\d+(\.\d+)?\s*[A-Za-z]+)', size_text)
+                    candidates = re.findall(r"(\d+(\.\d+)?\s*[A-Za-z]+)", size_text)
                     if candidates:
                         size_string = candidates[-1][0]
                         try:
@@ -422,32 +466,39 @@ def al_search(shared_state, start_time, request_from, search_string,
                     release_title = guess_title(shared_state, title, release_info)
 
                 if season and release_info.season != int(season):
-                    debug(f"Excluding {release_title} due to season mismatch: {release_info.season} != {season}")
+                    debug(
+                        f"Excluding {release_title} due to season mismatch: {release_info.season} != {season}"
+                    )
                     continue
 
                 payload = urlsafe_b64encode(
-                    f"{release_title}|{url}|{mirror}|{mb}|{release_id}|{imdb_id or ''}"
-                    .encode("utf-8")
+                    f"{release_title}|{url}|{mirror}|{mb}|{release_id}|{imdb_id or ''}".encode(
+                        "utf-8"
+                    )
                 ).decode("utf-8")
                 link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
 
-                releases.append({
-                    "details": {
-                        "title": release_title,
-                        "hostname": hostname,
-                        "imdb_id": imdb_id,
-                        "link": link,
-                        "mirror": mirror,
-                        "size": mb * 1024 * 1024,
-                        "date": date_str,
-                        "source": f"{url}#download_{release_id}"
-                    },
-                    "type": "protected"
-                })
+                releases.append(
+                    {
+                        "details": {
+                            "title": release_title,
+                            "hostname": hostname,
+                            "imdb_id": imdb_id,
+                            "link": link,
+                            "mirror": mirror,
+                            "size": mb * 1024 * 1024,
+                            "date": date_str,
+                            "source": f"{url}#download_{release_id}",
+                        },
+                        "type": "protected",
+                    }
+                )
 
         except Exception as e:
             info(f"{hostname}: error parsing search item: {e}")
-            mark_hostname_issue(hostname, "search", str(e) if "e" in dir() else "Error occurred")
+            mark_hostname_issue(
+                hostname, "search", str(e) if "e" in dir() else "Error occurred"
+            )
 
     elapsed = time.time() - start_time
     debug(f"Time taken: {elapsed:.2f}s ({hostname})")

quasarr/search/sources/by.py

@@ -12,9 +12,9 @@ from urllib.parse import quote_plus
 import requests
 from bs4 import BeautifulSoup
 
-from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
+from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
 from quasarr.providers.imdb_metadata import get_localized_title
-from quasarr.providers.log import info, debug
+from quasarr.providers.log import debug, info
 
 hostname = "by"
 supported_mirrors = ["rapidgator", "ddownload", "nitroflare"]
@@ -37,87 +37,108 @@ def extract_size(text):
     m = re.match(r"(\d+(?:[.,]\d+)?)\s*([A-Za-z]+)", text)
     if not m:
         raise ValueError(f"Invalid size format: {text!r}")
-    size_str = m.group(1).replace(',', '.')
+    size_str = m.group(1).replace(",", ".")
     sizeunit = m.group(2)
     size_float = float(size_str)  # convert to float here
     return {"size": size_float, "sizeunit": sizeunit}
 
 
-def _parse_posts(soup, shared_state, base_url, password, mirror_filter,
-                 is_search=False, request_from=None, search_string=None,
-                 season=None, episode=None):
+def _parse_posts(
+    soup,
+    shared_state,
+    base_url,
+    password,
+    mirror_filter,
+    is_search=False,
+    request_from=None,
+    search_string=None,
+    season=None,
+    episode=None,
+):
     releases = []
     if not is_search:
-        feed_container = soup.find('table', class_='AUDIO_ITEMLIST')  # it is actually called this way
+        feed_container = soup.find(
+            "table", class_="AUDIO_ITEMLIST"
+        )  # it is actually called this way
         candidates = []
         if feed_container:
-            for tbl in feed_container.find_all('table'):
+            for tbl in feed_container.find_all("table"):
                 if tbl.find(string=re.compile(r"Erstellt am:")):
                     candidates.append(tbl)
         items = candidates
     else:
-        search_table = soup.find('table', class_='SEARCH_ITEMLIST')
+        search_table = soup.find("table", class_="SEARCH_ITEMLIST")
         items = []
         if search_table:
             items = [
-                tr for tr in search_table.find_all('tr')
-                if tr.find('p', class_='TITLE') and tr.find('p', class_='TITLE').find('a', href=True)
+                tr
+                for tr in search_table.find_all("tr")
+                if tr.find("p", class_="TITLE")
+                and tr.find("p", class_="TITLE").find("a", href=True)
             ]
 
     for entry in items:
-        if entry.find('table'):
+        if entry.find("table"):
             continue  # Skip header rows
         try:
             if not is_search:
                 table = entry
                 # title & source
                 try:
-                    link_tag = table.find('th').find('a')
+                    link_tag = table.find("th").find("a")
                 except AttributeError:
-                    link_tag = table.find('a')
+                    link_tag = table.find("a")
                 title = link_tag.get_text(strip=True)
-                if 'lazylibrarian' in request_from.lower():
+                if "lazylibrarian" in request_from.lower():
                     # lazylibrarian can only detect specific date formats / issue numbering for magazines
                     title = shared_state.normalize_magazine_title(title)
                 else:
                     title = title.replace(" ", ".")
 
-                source = base_url + link_tag['href']
+                source = base_url + link_tag["href"]
                 # extract date and size
                 date_str = size_str = None
-                for row in table.find_all('tr', height=True):
-                    cols = row.find_all('td')
+                for row in table.find_all("tr", height=True):
+                    cols = row.find_all("td")
                     if len(cols) == 2:
                         label = cols[0].get_text(strip=True)
                         val = cols[1].get_text(strip=True)
-                        if label.startswith('Erstellt am'):
+                        if label.startswith("Erstellt am"):
                             date_str = val
-                        elif label.startswith('Größe'):
+                        elif label.startswith("Größe"):
                             size_str = val
-                published = convert_to_rss_date(date_str) if date_str else ''
-                size_info = extract_size(size_str) if size_str else {'size': '0', 'sizeunit': 'MB'}
-                mb = float(size_info['size'])
+                published = convert_to_rss_date(date_str) if date_str else ""
+                size_info = (
+                    extract_size(size_str)
+                    if size_str
+                    else {"size": "0", "sizeunit": "MB"}
+                )
+                mb = float(size_info["size"])
                 size_bytes = int(mb * 1024 * 1024)
                 imdb_id = None
             else:
                 row = entry
-                title_tag = row.find('p', class_='TITLE').find('a')
+                title_tag = row.find("p", class_="TITLE").find("a")
                 title = title_tag.get_text(strip=True)
-                if 'lazylibrarian' in request_from.lower():
+                if "lazylibrarian" in request_from.lower():
                     # lazylibrarian can only detect specific date formats / issue numbering for magazines
                     title = shared_state.normalize_magazine_title(title)
                 else:
                     title = title.replace(" ", ".")
-                    if not (RESOLUTION_REGEX.search(title) or CODEC_REGEX.search(title)):
+                    if not (
+                        RESOLUTION_REGEX.search(title) or CODEC_REGEX.search(title)
+                    ):
                         continue
 
-                if not shared_state.is_valid_release(title, request_from, search_string, season, episode):
+                if not shared_state.is_valid_release(
+                    title, request_from, search_string, season, episode
+                ):
                     continue
-                if XXX_REGEX.search(title) and 'xxx' not in search_string.lower():
+                if XXX_REGEX.search(title) and "xxx" not in search_string.lower():
                     continue
 
-                source = base_url + title_tag['href']
-                date_cell = row.find_all('td')[2]
+                source = base_url + title_tag["href"]
+                date_cell = row.find_all("td")[2]
                 date_str = date_cell.get_text(strip=True)
                 published = convert_to_rss_date(date_str)
                 size_bytes = 0
@@ -127,21 +148,25 @@ def _parse_posts(soup, shared_state, base_url, password, mirror_filter,
             payload = urlsafe_b64encode(
                 f"{title}|{source}|{mirror_filter}|{mb}|{password}|{imdb_id}|{hostname}".encode()
             ).decode()
-            link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
-
-            releases.append({
-                'details': {
-                    'title': title,
-                    'hostname': hostname,
-                    'imdb_id': imdb_id,
-                    'link': link,
-                    'mirror': mirror_filter,
-                    'size': size_bytes,
-                    'date': published,
-                    'source': source
-                },
-                'type': 'protected'
-            })
+            link = (
+                f"{shared_state.values['internal_address']}/download/?payload={payload}"
+            )
+
+            releases.append(
+                {
+                    "details": {
+                        "title": title,
+                        "hostname": hostname,
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror_filter,
+                        "size": size_bytes,
+                        "date": published,
+                        "source": source,
+                    },
+                    "type": "protected",
+                }
+            )
         except Exception as e:
             debug(f"Error parsing {hostname.upper()}: {e}")
             continue
@@ -150,7 +175,7 @@ def _parse_posts(soup, shared_state, base_url, password, mirror_filter,
 
 
 def by_feed(shared_state, start_time, request_from, mirror=None):
-    by = shared_state.values['config']('Hostnames').get(hostname)
+    by = shared_state.values["config"]("Hostnames").get(hostname)
     password = by
 
     if "lazylibrarian" in request_from.lower():
@@ -162,15 +187,24 @@ def by_feed(shared_state, start_time, request_from, mirror=None):
 
     base_url = f"https://{by}"
     url = f"{base_url}/{feed_type}"
-    headers = {'User-Agent': shared_state.values['user_agent']}
+    headers = {"User-Agent": shared_state.values["user_agent"]}
     try:
         r = requests.get(url, headers=headers, timeout=30)
         r.raise_for_status()
-        soup = BeautifulSoup(r.content, 'html.parser')
-        releases = _parse_posts(soup, shared_state, base_url, password, request_from=request_from, mirror_filter=mirror)
+        soup = BeautifulSoup(r.content, "html.parser")
+        releases = _parse_posts(
+            soup,
+            shared_state,
+            base_url,
+            password,
+            request_from=request_from,
+            mirror_filter=mirror,
+        )
     except Exception as e:
         info(f"Error loading {hostname.upper()} feed: {e}")
-        mark_hostname_issue(hostname, "feed", str(e) if "e" in dir() else "Error occurred")
+        mark_hostname_issue(
+            hostname, "feed", str(e) if "e" in dir() else "Error occurred"
+        )
         releases = []
     debug(f"Time taken: {time.time() - start_time:.2f}s ({hostname})")
 
@@ -179,13 +213,21 @@ def by_feed(shared_state, start_time, request_from, mirror=None):
     return releases
 
 
-def by_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
-    by = shared_state.values['config']('Hostnames').get(hostname)
+def by_search(
+    shared_state,
+    start_time,
+    request_from,
+    search_string,
+    mirror=None,
+    season=None,
+    episode=None,
+):
+    by = shared_state.values["config"]("Hostnames").get(hostname)
     password = by
 
     imdb_id = shared_state.is_imdb_id(search_string)
     if imdb_id:
-        title = get_localized_title(shared_state, imdb_id, 'de')
+        title = get_localized_title(shared_state, imdb_id, "de")
         if not title:
             info(f"Could not extract title from IMDb-ID {imdb_id}")
             return []
@@ -194,19 +236,28 @@ def by_search(shared_state, start_time, request_from, search_string, mirror=None
     base_url = f"https://{by}"
     q = quote_plus(search_string)
     url = f"{base_url}/?q={q}"
-    headers = {'User-Agent': shared_state.values['user_agent']}
+    headers = {"User-Agent": shared_state.values["user_agent"]}
     try:
         r = requests.get(url, headers=headers, timeout=10)
         r.raise_for_status()
-        soup = BeautifulSoup(r.content, 'html.parser')
+        soup = BeautifulSoup(r.content, "html.parser")
         releases = _parse_posts(
-            soup, shared_state, base_url, password, mirror_filter=mirror,
-            is_search=True, request_from=request_from,
-            search_string=search_string, season=season, episode=episode
+            soup,
+            shared_state,
+            base_url,
+            password,
+            mirror_filter=mirror,
+            is_search=True,
+            request_from=request_from,
+            search_string=search_string,
+            season=season,
+            episode=episode,
         )
     except Exception as e:
         info(f"Error loading {hostname.upper()} search: {e}")
-        mark_hostname_issue(hostname, "search", str(e) if "e" in dir() else "Error occurred")
+        mark_hostname_issue(
+            hostname, "search", str(e) if "e" in dir() else "Error occurred"
+        )
         releases = []
     debug(f"Time taken: {time.time() - start_time:.2f}s ({hostname})")