quasarr 0.0.1__tar.gz

quasarr-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RiX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quasarr-0.0.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: quasarr
+Version: 0.0.1
+Summary: Full template for python web projects with Docker, GitHub Actions, PyPI, and more.
+Home-page: https://github.com/rix1337/Quasarr
+Author: rix1337
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4==4.12.3
+Requires-Dist: bottle==0.12.25
+Requires-Dist: pycryptodomex==3.20.0
+Requires-Dist: requests
+
+# Quasarr
+
+[![PyPI version](https://badge.fury.io/py/quasarr.svg)](https://badge.fury.io/py/quasarr)
+[![GitHub Sponsorship](https://img.shields.io/badge/support-me-red.svg)](https://github.com/users/rix1337/sponsorship)
+
+JDownloader Bridge for Radarr and Sonarr.
+
+* Follow instructions to set up at least one hostname
+* Provide your [My JDownloader credentials](https://my.jdownloader.org)
+* Then use Quasarr's URL as 'Newznab Indexer' and 'SABnzbd Download Client' in Sonarr/Radarr.
+    * Leave settings at default
+    * Use this API key: `quasarr`
+
+**Warning: this is a very early dev version. Only tested with Radarr. Only one hostname supported.**
+
+# Setup
+
+`pip install quasarr`
+
+# Run
+
+```
+quasarr
+  --port=8080
+  --external_address=https://quasarr.example.org:9443
+  ```
+
+* External Address: required, if you want to fully use Quasarr from outside your local network
+
+# Docker
+
+```
+docker run -d \
+  --name="Quasarr" \
+  -p port:8080 \
+  -v /path/to/config/:/config:rw \
+  -e 'INTERNAL_ADDRESS'='http://quasarr:8080'
+  -e 'EXTERNAL_ADDRESS'='https://quasarr.example.org:9443'
+  rix1337/docker-quasarr:latest
+  ```
+
+* Internal Address: required so Radarr/Sonarr can reach Quasarr
+* External Address: required, if you want to fully use Quasarr from outside your local network

quasarr-0.0.1/README.md

@@ -0,0 +1,43 @@
+# Quasarr
+
+[![PyPI version](https://badge.fury.io/py/quasarr.svg)](https://badge.fury.io/py/quasarr)
+[![GitHub Sponsorship](https://img.shields.io/badge/support-me-red.svg)](https://github.com/users/rix1337/sponsorship)
+
+JDownloader Bridge for Radarr and Sonarr.
+
+* Follow instructions to set up at least one hostname
+* Provide your [My JDownloader credentials](https://my.jdownloader.org)
+* Then use Quasarr's URL as 'Newznab Indexer' and 'SABnzbd Download Client' in Sonarr/Radarr.
+    * Leave settings at default
+    * Use this API key: `quasarr`
+
+**Warning: this is a very early dev version. Only tested with Radarr. Only one hostname supported.**
+
+# Setup
+
+`pip install quasarr`
+
+# Run
+
+```
+quasarr
+  --port=8080
+  --external_address=https://quasarr.example.org:9443
+  ```
+
+* External Address: required, if you want to fully use Quasarr from outside your local network
+
+# Docker
+
+```
+docker run -d \
+  --name="Quasarr" \
+  -p port:8080 \
+  -v /path/to/config/:/config:rw \
+  -e 'INTERNAL_ADDRESS'='http://quasarr:8080'
+  -e 'EXTERNAL_ADDRESS'='https://quasarr.example.org:9443'
+  rix1337/docker-quasarr:latest
+  ```
+
+* Internal Address: required so Radarr/Sonarr can reach Quasarr
+* External Address: required, if you want to fully use Quasarr from outside your local network

quasarr-0.0.1/quasarr/__init__.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import argparse
+import multiprocessing
+import os
+import socket
+import sys
+import tempfile
+import time
+
+from quasarr.arr import api
+from quasarr.persistence.config import Config, get_clean_hostnames
+from quasarr.persistence.sqlite_database import DataBase
+from quasarr.providers import shared_state, version
+from quasarr.providers.setup import path_config, hostnames_config, nx_credentials_config, jdownloader_config
+from quasarr.providers.shared_state import sanitize_external_address
+
+
+def run():
+    with multiprocessing.Manager() as manager:
+        shared_state_dict = manager.dict()
+        shared_state_lock = manager.Lock()
+        shared_state.set_state(shared_state_dict, shared_state_lock)
+
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--port", help="Desired Port, defaults to 8080")
+        parser.add_argument("--internal_address", help="Must be provided when running in Docker")
+        parser.add_argument("--external_address",
+                            help="Address/URL of Quasarr available outside your LAN, must include port and protocol")
+        arguments = parser.parse_args()
+
+        sys.stdout = Unbuffered(sys.stdout)
+
+        print(f"""┌────────────────────────────────────┐
+  Quasarr {version.get_version()} by RiX
+  https://github.com/rix1337/Quasarr
+└────────────────────────────────────┘""")
+
+        port = int('8080')
+
+        config_path = ""
+        if os.environ.get('DOCKER'):
+            config_path = "/config"
+            if arguments.internal_address:
+                internal_address = arguments.internal_address
+            else:
+                print(
+                    "You must set the INTERNAL_ADDRESS variable to a locally reachable URL, e.g. http://localhost:8080")
+                print("The local URL will be used by Radarr/Sonarr to connect to Quasarr")
+                print("Stopping Quasarr...")
+                sys.exit(1)
+        else:
+            if arguments.port:
+                port = int(arguments.port)
+            internal_address = f'http://{check_ip()}'
+
+        external_address = ""
+        if arguments.external_address:
+            sanitized_url = sanitize_external_address(arguments.external_address)
+            if sanitized_url:
+                external_address = sanitized_url
+
+        shared_state.set_connection_info(internal_address, port, external_address)
+
+        if not config_path:
+            config_path_file = "Quasarr.conf"
+            if not os.path.exists(config_path_file):
+                path_config(shared_state)
+            with open(config_path_file, "r") as f:
+                config_path = f.readline().strip()
+
+        os.makedirs(config_path, exist_ok=True)
+
+        try:
+            temp_file = tempfile.TemporaryFile(dir=config_path)
+            temp_file.close()
+        except Exception as e:
+            print(f'Could not access "{config_path}": {e}"'
+                  f'Stopping Quasarr...')
+            sys.exit(1)
+
+        shared_state.set_files(config_path)
+        shared_state.update("config", Config)
+        shared_state.update("database", DataBase)
+        shared_state.update("user_agent",
+                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+
+        print(f'Config path: "{config_path}"')
+
+        shared_state.set_sites()
+
+        if not get_clean_hostnames(shared_state):
+            hostnames_config(shared_state)
+            get_clean_hostnames(shared_state)
+
+        if Config('Hostnames').get('nx'):
+            user = Config('NX').get('user')
+            password = Config('NX').get('password')
+            if not user or not password:
+                nx_credentials_config(shared_state)
+
+        config = Config('JDownloader')
+        user = config.get('user')
+        password = config.get('password')
+        device = config.get('device')
+
+        if not user or not password or not device:
+            jdownloader_config(shared_state)
+
+        jdownloader = multiprocessing.Process(target=jdownloader_connection,
+                                              args=(shared_state_dict, shared_state_lock))
+        jdownloader.start()
+
+        print(f'\nQuasarr API now running at "{shared_state.values["internal_address"]}"')
+        print('Use this exact URL as "Newznab Indexer" and "SABnzbd Download Client" in Sonarr/Radarr')
+        print("Leave settings at default and use this API key: 'quasarr'")
+        if shared_state.values["external_address"] != shared_state.values["internal_address"]:
+            print(f'External address: "{shared_state.values["external_address"]}"')
+
+        try:
+            api(shared_state_dict, shared_state_lock)
+        except KeyboardInterrupt:
+            sys.exit(0)
+
+
+def jdownloader_connection(shared_state_dict, shared_state_lock):
+    shared_state.set_state(shared_state_dict, shared_state_lock)
+
+    shared_state.set_device_from_config()
+
+    connection_established = shared_state.get_device() and shared_state.get_device().name
+    if not connection_established:
+        i = 0
+        while i < 10:
+            i += 1
+            print(f'Connection {i} to JDownloader failed. Device name: "{shared_state.values["device"]}"')
+            time.sleep(60)
+            shared_state.set_device_from_config()
+            connection_established = shared_state.get_device() and shared_state.get_device().name
+            if connection_established:
+                break
+
+    if connection_established:
+        print(f'Connection to JDownloader successful. Device name: "{shared_state.get_device().name}"')
+    else:
+        print('Error connecting to JDownloader! Stopping Quasarr!')
+        sys.exit(1)
+
+
+class Unbuffered(object):
+    def __init__(self, stream):
+        self.stream = stream
+
+    def write(self, data):
+        self.stream.write(data)
+        self.stream.flush()
+
+    def writelines(self, datas):
+        self.stream.writelines(datas)
+        self.stream.flush()
+
+    def __getattr__(self, attr):
+        return getattr(self.stream, attr)
+
+
+def check_ip():
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(('10.255.255.255', 0))
+        ip = s.getsockname()[0]
+    except:
+        ip = '127.0.0.1'
+    finally:
+        s.close()
+    return ip

quasarr-0.0.1/quasarr/arr/__init__.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from base64 import urlsafe_b64decode
+from xml.etree import ElementTree as ET
+
+from bottle import Bottle, request, redirect
+
+from quasarr.downloads import download_package, delete_package, get_packages
+from quasarr.providers import shared_state
+from quasarr.providers.html_templates import render_centered_html
+from quasarr.providers.web_server import Server
+from quasarr.search import get_search_results
+
+
+def api(shared_state_dict, shared_state_lock):
+    shared_state.set_state(shared_state_dict, shared_state_lock)
+
+    app = Bottle()
+
+    @app.get('/')
+    def index():
+        info = f"""
+        <h1>Quasarr</h1>
+        <p>
+            <code id="current-url" style="background-color: #f0f0f0; padding: 5px; border-radius: 3px;">
+                {shared_state.values["external_address"]}
+            </code>
+        </p>
+        <p>Use this exact URL as 'Newznab Indexer' and 'SABnzbd Download Client' in Sonarr/Radarr. 
+        Leave settings at default and use this API key: 'quasarr'</p>
+        """
+        return render_centered_html(info)
+
+    @app.get('/download/')
+    def fake_download_container():
+        payload = request.query.payload
+        decoded_payload = urlsafe_b64decode(payload).decode("utf-8").split("|")
+        title = decoded_payload[0]
+        url = decoded_payload[1]
+
+        request_from = request.headers.get('User-Agent')
+        if request_from:
+            if not any(arr_client in request_from for arr_client in ["Radarr", "Sonarr"]):
+                redirect(url, 302)
+
+        return f'<nzb><file title="{title}" url="{url}"/></nzb>'
+
+    @app.post('/api')
+    def download():
+        downloads = request.files.getall('name')
+        nzo_ids = []
+        for upload in downloads:
+            file_content = upload.file.read()
+            root = ET.fromstring(file_content)
+            title = root.find(".//file").attrib["title"]
+            url = root.find(".//file").attrib["url"]
+            print(f"Attempting download for {title}")
+
+            nzo_id = download_package(shared_state, title, url)
+            if nzo_id:
+                print(f"Download started for {title}")
+                nzo_ids.append(nzo_id)
+            else:
+                print(f"Download failed for {title}")
+
+        return {
+            "status": True,
+            "nzo_ids": nzo_ids
+        }
+
+    @app.get('/api')
+    def fake_api():
+        api_type = 'sabnzbd' if request.query.mode and request.query.apikey else 'newznab' if request.query.t else None
+
+        if api_type == 'sabnzbd':
+            try:
+                mode = request.query.mode
+                if mode == "version":
+                    return {
+                        "version": "4.3.2"
+                    }
+                elif mode == "get_config":
+                    return {
+                        "config": {
+                            "misc": {
+                                "quasarr": True,
+                                "complete_dir": "/tmp/"
+                            },
+                            "categories": [
+                                {
+                                    "name": "*",
+                                    "order": 0,
+                                    "dir": "",
+                                },
+                                {
+                                    "name": "movies",
+                                    "order": 1,
+                                    "dir": "",
+                                },
+                                {
+                                    "name": "tv",
+                                    "order": 2,
+                                    "dir": "",
+                                }
+                            ]
+                        }
+                    }
+                elif mode == "fullstatus":
+                    return {
+                        "status": {
+                            "quasarr": True
+                        }
+                    }
+                elif mode == "queue" or mode == "history":
+                    if request.query.name and request.query.name == "delete":
+                        package_id = request.query.value
+                        deleted = delete_package(shared_state, package_id)
+                        print(f"Package {package_id} deleted {'successfully' if deleted else 'unsuccessfully'}")
+                        return {
+                            "status": deleted,
+                            "nzo_ids": [package_id]
+                        }
+
+                    packages = get_packages(shared_state)
+                    if mode == "queue":
+                        return {
+                            "queue": {
+                                "paused": False,
+                                "slots": packages["queue"]
+                            }
+                        }
+                    elif mode == "history":
+                        return {
+                            "history": {
+                                "paused": False,
+                                "slots": packages["history"]
+                            }
+                        }
+            except Exception as e:
+                print(f"Error: {e}")
+            return {
+                "status": False
+            }
+
+        elif api_type == 'newznab':
+            try:
+                mode = request.query.t
+                if mode == 'movie':
+                    if request.query.imdbid:
+                        imdb_id = f"tt{request.query.imdbid}"
+                    else:
+                        imdb_id = None
+
+                    request_from = request.headers.get('User-Agent')
+
+                    releases = get_search_results(shared_state, request_from, imdb_id=imdb_id)
+
+                    items = ""
+
+                    for release in releases:
+                        release = release["details"]
+
+                        items += f'''
+                        <item>
+                            <title>{release["title"]}</title>
+                            <guid isPermaLink="True">{release["link"]}</guid>
+                            <link>{release["link"]}</link>
+                            <comments>{release["link"]}</comments>
+                            <pubDate>{release["date"]}</pubDate>
+                            <enclosure url="{release["link"]}" length="{release["size"]}" type="application/x-nzb" />
+                        </item>'''
+
+                    return f'''<?xml version="1.0" encoding="UTF-8"?>
+                                <rss version="2.0">
+                                    <channel>
+                                        {items}
+                                    </channel>
+                                </rss>'''
+                elif mode == 'caps':
+                    return '''<?xml version="1.0" encoding="UTF-8"?>
+                    <caps>
+                      <categories>
+                          <category id="2000" name="Movies">
+                              <subcat id="2010" name="Foreign"/>
+                              <subcat id="2020" name="Other"/>
+                              <subcat id="2030" name="SD"/>
+                              <subcat id="2040" name="HD"/>
+                              <subcat id="2050" name="BluRay"/>
+                              <subcat id="2060" name="3D"/>
+                          </category>
+                          <category id="5000" name="TV">
+                              <subcat id="5020" name="Foreign"/>
+                              <subcat id="5030" name="SD"/>
+                              <subcat id="5040" name="HD"/>
+                              <subcat id="5050" name="Other"/>
+                              <subcat id="5060" name="Sport"/>
+                          </category>
+                      </categories>
+                    </caps>'''
+            except Exception as e:
+                print(f"Error: {e}")
+            return {"error": True}
+
+    Server(app, listen='0.0.0.0', port=shared_state.values["port"]).serve_forever()

quasarr-0.0.1/quasarr/downloads/__init__.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from quasarr.downloads.sources.nx import get_nx_download_links
+from quasarr.providers.myjd_api import TokenExpiredException, RequestTimeoutException, MYJDException
+
+
+def get_packages(shared_state):
+    packages = []
+
+    protected_packages = shared_state.get_db("to_decrypt").retrieve_all_titles()  # todo not implemented yet
+    if protected_packages:
+        for package in protected_packages:
+            packages.append({
+                "details": package,
+                "location": "queue",
+                "type": "protected"
+            })
+    try:
+        linkgrabber_packages = shared_state.get_device().linkgrabber.query_packages()
+    except (TokenExpiredException, RequestTimeoutException, MYJDException):
+        linkgrabber_packages = []
+
+    if linkgrabber_packages:
+        for package in linkgrabber_packages:
+            packages.append({
+                "details": package,
+                "location": "queue",
+                "type": "linkgrabber"
+            })
+    try:
+        downloader_packages = shared_state.get_device().downloads.query_packages()
+    except (TokenExpiredException, RequestTimeoutException, MYJDException):
+        downloader_packages = []
+
+    if downloader_packages:
+        for package in downloader_packages:
+            finished = False
+            try:
+                finished = package["finished"]
+            except KeyError:
+                pass
+            packages.append({
+                "details": package,
+                "location": "history" if finished else "queue",
+                "type": "downloader"
+            })
+
+    downloads = {
+        "queue": [],
+        "history": []
+    }
+    for package in packages:
+        queue_index = 0
+        history_index = 0
+
+        def format_eta(seconds):
+            hours = seconds // 3600
+            minutes = (seconds % 3600) // 60
+            seconds = seconds % 60
+            return f"{hours:02}:{minutes:02}:{seconds:02}"
+
+        if package["location"] == "queue":
+            time_left = "2385:09:09"  # to signify that its not running
+            if package["type"] == "protected":  # todo load from db
+                details = package["details"]
+                name = "Protected package"
+                mb = 1000
+                mb_left = mb
+                nzo_id = "Quasarr_protected_1"
+            elif package["type"] == "linkgrabber":
+                details = package["details"]
+                name = details["name"]
+                mb = int(details["bytesTotal"]) / (1024 * 1024)
+                mb_left = mb
+                nzo_id = "Quasarr_protected_234"
+            elif package["type"] == "downloader":
+                details = package["details"]
+                name = details["name"]
+                try:
+                    if details["eta"]:
+                        time_left = format_eta(int(details["eta"]))
+                except KeyError:
+                    pass
+                mb = int(details["bytesTotal"]) / (1024 * 1024)
+                mb_left = (int(details["bytesTotal"]) - int(details["bytesLoaded"])) / (1024 * 1024)
+                nzo_id = "Quasarr_protected_2"
+
+            try:
+                downloads["queue"].append({
+                    "index": queue_index,
+                    "nzo_id": nzo_id,
+                    "priority": "Normal",
+                    "filename": name,
+                    "cat": "movies",
+                    "mbleft": int(mb_left),
+                    "mb": int(mb),
+                    "status": "Downloading",
+                    "timeleft": time_left,
+                })
+            except:
+                print(f"Parameters missing for {package}")
+            queue_index += 1
+        elif package["location"] == "history":
+            package = package["details"]
+            name = package["name"]
+            bytes = int(package["bytesLoaded"])
+            storage = package["saveTo"]
+            downloads["history"].append({
+                "fail_message": "",
+                "category": "movies",
+                "storage": storage,
+                "status": "Completed",
+                "nzo_id": "Quasarr_nzo_3",
+                "name": name,
+                "bytes": int(bytes),
+            })
+            history_index += 1
+        else:
+            print(f"Invalid package location {package['location']}")
+
+    return downloads
+
+
+def download_package(shared_state, title, url):
+    package_id = ""
+
+    nx = shared_state.values["config"]("Hostnames").get("nx")
+    if nx.lower() in url.lower():
+        links = get_nx_download_links(shared_state, url, title)
+        print(f"Decrypted {len(links)} download links for {title}")
+
+        download_links = str(links).replace(" ", "")
+        download_path = "Quasarr/<jd:packagename>"
+        package_id = f"Quasarr_decrypted_{str(hash(title + url)).replace('-', '')}"
+
+        added = shared_state.get_device().linkgrabber.add_links(params=[
+            {
+                "autostart": True,
+                "links": download_links,
+                "packageName": title,
+                "extractPassword": nx,
+                "priority": "DEFAULT",
+                "downloadPassword": nx,
+                "destinationFolder": download_path,
+                "comment": package_id,
+                "overwritePackagizerRules": True
+            }
+        ])
+        if not added:
+            print(f"Failed to add {title} to linkgrabber")
+            package_id = ""
+
+    # Todo links are protected -> add them to the database for decryption in the web ui
+
+    return package_id
+
+
+def delete_package(shared_state, package_id):
+    deleted = False
+    # todo implement (detect package by id from jdownloader or table)
+    # delete it at the correct location
+    print(f"Deleting package {package_id} - not implemented yet")
+    return deleted