quasarr 1.3.5__py3-none-any.whl → 1.20.4__py3-none-any.whl

quasarr/api/arr/__init__.py

@@ -7,14 +7,16 @@ import xml.sax.saxutils as sax_utils
 from base64 import urlsafe_b64decode
 from datetime import datetime
 from functools import wraps
+from urllib.parse import urlparse, parse_qs
 from xml.etree import ElementTree
 
 from bottle import abort, request
 
-from quasarr.downloads import download, delete_package, get_packages
+from quasarr.downloads import download
+from quasarr.downloads.packages import get_packages, delete_package
 from quasarr.providers import shared_state
 from quasarr.providers.log import info, debug
-from quasarr.providers.tvmaze_metadata import get_title_from_tvrage_id
+from quasarr.providers.version import get_version
 from quasarr.search import get_search_results
 from quasarr.storage.config import Config
 
@@ -64,15 +66,21 @@ def setup_arr_routes(app):
             password = root.find(".//file").attrib.get("password")
             imdb_id = root.find(".//file").attrib.get("imdb_id")
 
-            info(f"Attempting download for {title}")
+            info(f'Attempting download for "{title}"')
             request_from = request.headers.get('User-Agent')
-            package_id = download(shared_state, request_from, title, url, mirror, size_mb, password, imdb_id)
-
-            if package_id:
-                info(f"{title} added successfully!")
+            downloaded = download(shared_state, request_from, title, url, mirror, size_mb, password, imdb_id)
+            try:
+                success = downloaded["success"]
+                package_id = downloaded["package_id"]
+                title = downloaded["title"]
+
+                if success:
+                    info(f'"{title}" added successfully!')
+                else:
+                    info(f'"{title}" added unsuccessfully! See log for details.')
                 nzo_ids.append(package_id)
-            else:
-                info(f"{title} could not be added!")
+            except KeyError:
+                info(f'Failed to download "{title}" - no package_id returned')
 
         return {
             "status": True,
@@ -86,12 +94,25 @@ def setup_arr_routes(app):
         api_type = 'arr_download_client' if request.query.mode else 'arr_indexer' if request.query.t else None
 
         if api_type == 'arr_download_client':
-            # This yields with a mock SABnzbd API response based on the My JDownloader integration
+            # This builds a mock SABnzbd API response based on the My JDownloader integration
             try:
                 mode = request.query.mode
-                if mode == "version":
+                if mode == "auth":
+                    return {
+                        "auth": "apikey"
+                    }
+                elif mode == "version":
                     return {
-                        "version": "4.3.2"
+                        "version": f"Quasarr {get_version()}"
+                    }
+                elif mode == "get_cats":
+                    return {
+                        "categories": [
+                            "*",
+                            "movies",
+                            "tv",
+                            "docs"
+                        ]
                     }
                 elif mode == "get_config":
                     return {
@@ -115,7 +136,12 @@ def setup_arr_routes(app):
                                     "name": "tv",
                                     "order": 2,
                                     "dir": "",
-                                }
+                                },
+                                {
+                                    "name": "docs",
+                                    "order": 3,
+                                    "dir": "",
+                                },
                             ]
                         }
                     }
@@ -125,6 +151,66 @@ def setup_arr_routes(app):
                             "quasarr": True
                         }
                     }
+                elif mode == "addurl":
+                    raw_name = getattr(request.query, "name", None)
+                    if not raw_name:
+                        abort(400, "missing or empty 'name' parameter")
+
+                    payload = False
+                    try:
+                        parsed = urlparse(raw_name)
+                        qs = parse_qs(parsed.query)
+                        payload = qs.get("payload", [None])[0]
+                    except Exception as e:
+                        abort(400, f"invalid URL in 'name': {e}")
+                    if not payload:
+                        abort(400, "missing 'payload' parameter in URL")
+
+                    title = url = mirror = size_mb = password = imdb_id = None
+                    try:
+                        decoded = urlsafe_b64decode(payload.encode()).decode()
+                        parts = decoded.split("|")
+                        if len(parts) != 6:
+                            raise ValueError(f"expected 6 fields, got {len(parts)}")
+                        title, url, mirror, size_mb, password, imdb_id = parts
+                    except Exception as e:
+                        abort(400, f"invalid payload format: {e}")
+
+                    mirror = None if mirror == "None" else mirror
+
+                    nzo_ids = []
+                    info(f'Attempting download for "{title}"')
+                    request_from = "lazylibrarian"
+
+                    downloaded = download(
+                        shared_state,
+                        request_from,
+                        title,
+                        url,
+                        mirror,
+                        size_mb,
+                        password or None,
+                        imdb_id or None,
+                    )
+
+                    try:
+                        success = downloaded["success"]
+                        package_id = downloaded["package_id"]
+                        title = downloaded.get("title", title)
+
+                        if success:
+                            info(f'"{title}" added successfully!')
+                        else:
+                            info(f'"{title}" added unsuccessfully! See log for details.')
+                        nzo_ids.append(package_id)
+                    except KeyError:
+                        info(f'Failed to download "{title}" - no package_id returned')
+
+                    return {
+                        "status": True,
+                        "nzo_ids": nzo_ids
+                    }
+
                 elif mode == "queue" or mode == "history":
                     if request.query.name and request.query.name == "delete":
                         package_id = request.query.value
@@ -139,109 +225,133 @@ def setup_arr_routes(app):
                         return {
                             "queue": {
                                 "paused": False,
-                                "slots": packages["queue"]
+                                "slots": packages.get("queue", [])
                             }
                         }
                     elif mode == "history":
                         return {
                             "history": {
                                 "paused": False,
-                                "slots": packages["history"]
+                                "slots": packages.get("history", [])
                             }
                         }
             except Exception as e:
                 info(f"Error loading packages: {e}")
                 info(traceback.format_exc())
+            info(f"[ERROR] Unknown download client request: {dict(request.query)}")
             return {
                 "status": False
             }
 
         elif api_type == 'arr_indexer':
-            # this yields with a mock Newznab API response based on Quasarr search
+            # this builds a mock Newznab API response based on Quasarr search
             try:
                 if mirror:
                     debug(f'Search will only return releases that match this mirror: "{mirror}"')
 
                 mode = request.query.t
+                request_from = request.headers.get('User-Agent')
+
                 if mode == 'caps':
+                    info(f"Providing indexer capability information to {request_from}")
                     return '''<?xml version="1.0" encoding="UTF-8"?>
-                                    <caps>
-                                      <categories>
-                                          <category id="2000" name="Movies">
-                                          </category>
-                                          <category id="5000" name="TV">
-                                          </category>
-                                      </categories>
-                                    </caps>'''
-                elif mode in ['movie', 'tvsearch', 'search']:
-                    request_from = request.headers.get('User-Agent')
-
+                                <caps>
+                                  <server 
+                                    version="1.33.7" 
+                                    title="Quasarr" 
+                                    url="https://quasarr.indexer/" 
+                                    email="support@quasarr.indexer" 
+                                  />
+                                  <limits max="9999" default="9999" />
+                                  <registration available="no" open="no" />
+                                  <searching>
+                                    <search available="yes" supportedParams="q" />
+                                    <tv-search available="yes" supportedParams="imdbid,season,ep" />
+                                    <movie-search available="yes" supportedParams="imdbid" />
+                                  </searching>
+                                  <categories>
+                                    <category id="5000" name="TV" />
+                                    <category id="2000" name="Movies" />
+                                    <category id="7000" name="Books">
+                                  </category>
+                                  </categories>
+                                </caps>'''
+                elif mode in ['movie', 'tvsearch', 'book', 'search']:
                     releases = []
 
-                    if mode == 'movie':
-                        # only imdb is implemented
-                        search_param = f"tt{getattr(request.query, 'imdbid', '')}" \
-                            if getattr(request.query, 'imdbid', '') else ""
-
-                        releases = get_search_results(shared_state, request_from,
-                                                      search_string=search_param,
-                                                      mirror=mirror
-                                                      )
-
-                    elif mode == 'search':
-                        debug(f'Search in Anime-Order is not supported. Ignoring request: {dict(request.query)}')
-
-                    elif mode == 'tvsearch':
-                        season = getattr(request.query, 'season', "")
-                        episode = getattr(request.query, 'ep', "")
-                        # only plain search string and tvrage id is implemented
-                        search_param = getattr(request.query, 'q', "")
-                        if not search_param:
-                            tvrage_id = getattr(request.query, 'rid', "")
-                            if tvrage_id:
-                                search_param = get_title_from_tvrage_id(tvrage_id)
-
-                        offset = getattr(request.query, 'offset', "")  # ignoring offset higher than 0 on purpose
-                        if int(offset) == 0:
+                    try:
+                        offset = int(getattr(request.query, 'offset', 0))
+                    except (AttributeError, ValueError):
+                        offset = 0
+
+                    if offset > 0:
+                        debug(f"Ignoring offset parameter: {offset} - it leads to redundant requests")
+
+                    else:
+                        if mode == 'movie':
+                            # supported params: imdbid
+                            imdb_id = getattr(request.query, 'imdbid', '')
+
                             releases = get_search_results(shared_state, request_from,
-                                                          search_string=search_param,
+                                                          imdb_id=imdb_id,
+                                                          mirror=mirror
+                                                          )
+
+                        elif mode == 'tvsearch':
+                            # supported params: imdbid, season, ep
+                            imdb_id = getattr(request.query, 'imdbid', '')
+                            season = getattr(request.query, 'season', None)
+                            episode = getattr(request.query, 'ep', None)
+                            releases = get_search_results(shared_state, request_from,
+                                                          imdb_id=imdb_id,
                                                           mirror=mirror,
                                                           season=season,
                                                           episode=episode
                                                           )
-                        else:
-                            debug(f'Offset higher than 0 is not supported. Ignoring request: {dict(request.query)}')
+                        elif mode == 'book':
+                            author = getattr(request.query, 'author', '')
+                            title = getattr(request.query, 'title', '')
+                            search_phrase = " ".join(filter(None, [author, title]))
+                            releases = get_search_results(shared_state, request_from,
+                                                          search_phrase=search_phrase,
+                                                          mirror=mirror
+                                                          )
 
-                    items = ""
-                    if not releases:
-                        items += f'''
-                            <item>
-                                <title>No releases found</title>
-                                <link></link>
-                                <pubDate>{datetime.now().strftime('%a, %d %b %Y %H:%M:%S %z')}</pubDate>
-                                <enclosure url="_" length="0" type="application/x-nzb"/>
-                                <guid></guid>
-                                <comments></comments>
-                                <description></description>
-                            </item>'''
+                        elif mode == 'search':
+                            if "lazylibrarian" in request_from.lower():
+                                search_phrase = getattr(request.query, 'q', '')
+                                releases = get_search_results(shared_state, request_from,
+                                                              search_phrase=search_phrase,
+                                                              mirror=mirror
+                                                              )
+                            else:
+                                info(
+                                    f'Ignoring search request from {request_from} - only imdbid searches are supported')
+                                releases = [{}]  # sonarr expects this but we will not support non-imdbid searches
 
+                    items = ""
                     for release in releases:
-                        release = release["details"]
+                        release = release.get("details", {})
+
+                        # Ensure clean XML output
+                        title = sax_utils.escape(release.get("title", ""))
+                        source = sax_utils.escape(release.get("source", ""))
 
-                        prefix = f'[{release["hostname"].upper()}]'
+                        if not "lazylibrarian" in request_from.lower():
+                            title = f'[{release.get("hostname", "").upper()}] {title}'
 
                         items += f'''
                         <item>
-                            <title>{prefix} {sax_utils.escape(release["title"])}</title>
-                            <guid isPermaLink="True">{release["link"]}</guid>
-                            <link>{release["link"]}</link>
-                            <comments>{release["source"]}</comments>
-                            <pubDate>{release["date"]}</pubDate>
-                            <enclosure url="{release["link"]}" length="{release["size"]}" type="application/x-nzb" />
+                            <title>{title}</title>
+                            <guid isPermaLink="True">{release.get("link", "")}</guid>
+                            <link>{release.get("link", "")}</link>
+                            <comments>{source}</comments>
+                            <pubDate>{release.get("date", datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000"))}</pubDate>
+                            <enclosure url="{release.get("link", "")}" length="{release.get("size", 0)}" type="application/x-nzb" />
                         </item>'''
 
                     return f'''<?xml version="1.0" encoding="UTF-8"?>
-                                <rss version="2.0">
+                                <rss>
                                     <channel>
                                         {items}
                                     </channel>
@@ -249,6 +359,15 @@ def setup_arr_routes(app):
             except Exception as e:
                 info(f"Error loading search results: {e}")
                 info(traceback.format_exc())
-
-        info(f"Unknown request: {dict(request.query)}")
+            info(f"[ERROR] Unknown indexer request: {dict(request.query)}")
+            return '''<?xml version="1.0" encoding="UTF-8"?>
+                        <rss>
+                            <channel>
+                                <title>Quasarr Indexer</title>
+                                <description>Quasarr Indexer API</description>
+                                <link>https://quasarr.indexer/</link>
+                            </channel>
+                        </rss>'''
+
+        info(f"[ERROR] Unknown general request: {dict(request.query)}")
         return {"error": True}