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

quasarr/providers/myjd_api.py

@@ -38,7 +38,7 @@ import requests
 import urllib3
 from Cryptodome.Cipher import AES
 
-from quasarr.providers.log import info, debug
+from quasarr.providers.log import debug, info
 from quasarr.providers.version import get_version
 
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
@@ -62,7 +62,7 @@ def pad(s):
 
 
 def unpad(s):
-    return s[0:-s[-1]]
+    return s[0 : -s[-1]]
 
 
 class Update:
@@ -72,7 +72,7 @@ class Update:
 
     def __init__(self, device):
         self.device = device
-        self.url = '/update'
+        self.url = "/update"
 
     def restart_and_update(self):
         """
@@ -111,7 +111,7 @@ class Config:
 
     def __init__(self, device):
         self.device = device
-        self.url = '/config'
+        self.url = "/config"
 
     def list(self):
         """
@@ -156,7 +156,7 @@ class DownloadController:
 
     def __init__(self, device):
         self.device = device
-        self.url = '/downloadcontroller'
+        self.url = "/downloadcontroller"
 
     def start_downloads(self):
         """
@@ -182,23 +182,27 @@ class Linkgrabber:
 
     def __init__(self, device):
         self.device = device
-        self.url = '/linkgrabberv2'
+        self.url = "/linkgrabberv2"
 
     def is_collecting(self):
         resp = self.device.action(self.url + "/isCollecting")
         return resp
 
-    def add_links(self,
-                  params=[{
-                      "autostart": True,
-                      "links": None,
-                      "packageName": None,
-                      "extractPassword": None,
-                      "priority": "DEFAULT",
-                      "downloadPassword": None,
-                      "destinationFolder": None,
-                      "overwritePackagizerRules": False
-                  }]):
+    def add_links(
+        self,
+        params=[
+            {
+                "autostart": True,
+                "links": None,
+                "packageName": None,
+                "extractPassword": None,
+                "priority": "DEFAULT",
+                "downloadPassword": None,
+                "destinationFolder": None,
+                "overwritePackagizerRules": False,
+            }
+        ],
+    ):
         """
         Add links to the linkcollector
 
@@ -215,12 +219,7 @@ class Linkgrabber:
         resp = self.device.action(self.url + "/addLinks", params)
         return resp
 
-    def cleanup(self,
-                action,
-                mode,
-                selection_type,
-                link_ids=[],
-                package_ids=[]):
+    def cleanup(self, action, mode, selection_type, link_ids=[], package_ids=[]):
         """
         Clean packages and/or links of the linkgrabber list.
         Requires at least a package_ids or link_ids list, or both.
@@ -258,23 +257,27 @@ class Linkgrabber:
         resp = self.device.action(self.url + "/moveToDownloadlist", params)
         return resp
 
-    def query_links(self,
-                    params=[{
-                        "bytesTotal": True,
-                        "comment": True,
-                        "status": True,
-                        "enabled": True,
-                        "maxResults": -1,
-                        "startAt": 0,
-                        "hosts": True,
-                        "url": True,
-                        "availability": True,
-                        "variantIcon": True,
-                        "variantName": True,
-                        "variantID": True,
-                        "variants": True,
-                        "priority": True
-                    }]):
+    def query_links(
+        self,
+        params=[
+            {
+                "bytesTotal": True,
+                "comment": True,
+                "status": True,
+                "enabled": True,
+                "maxResults": -1,
+                "startAt": 0,
+                "hosts": True,
+                "url": True,
+                "availability": True,
+                "variantIcon": True,
+                "variantName": True,
+                "variantID": True,
+                "variants": True,
+                "priority": True,
+            }
+        ],
+    ):
         """
 
         Get the links in the linkcollector/linkgrabber
@@ -288,25 +291,28 @@ class Linkgrabber:
         resp = self.device.action(self.url + "/queryLinks", params)
         return resp
 
-    def query_packages(self, params=[
-        {
-            "bytesLoaded": True,
-            "bytesTotal": True,
-            "comment": True,
-            "enabled": True,
-            "eta": True,
-            "priority": False,
-            "finished": True,
-            "running": True,
-            "speed": True,
-            "status": True,
-            "childCount": True,
-            "hosts": True,
-            "saveTo": True,
-            "maxResults": -1,
-            "startAt": 0,
-        }
-    ]):
+    def query_packages(
+        self,
+        params=[
+            {
+                "bytesLoaded": True,
+                "bytesTotal": True,
+                "comment": True,
+                "enabled": True,
+                "eta": True,
+                "priority": False,
+                "finished": True,
+                "running": True,
+                "speed": True,
+                "status": True,
+                "childCount": True,
+                "hosts": True,
+                "saveTo": True,
+                "maxResults": -1,
+                "startAt": 0,
+            }
+        ],
+    ):
         """
         Get the links in the linkgrabber list
         """
@@ -323,12 +329,7 @@ class Downloads:
         self.device = device
         self.url = "/downloadsV2"
 
-    def cleanup(self,
-                action,
-                mode,
-                selection_type,
-                link_ids=[],
-                package_ids=[]):
+    def cleanup(self, action, mode, selection_type, link_ids=[], package_ids=[]):
         """
         Clean packages and/or links of the linkgrabber list.
         Requires at least a package_ids or link_ids list, or both.
@@ -349,50 +350,58 @@ class Downloads:
         resp = self.device.action(self.url + "/cleanup", params)
         return resp
 
-    def query_links(self,
-                    params=[{
-                        "bytesTotal": True,
-                        "comment": True,
-                        "status": True,
-                        "enabled": True,
-                        "maxResults": -1,
-                        "startAt": 0,
-                        "packageUUIDs": [],
-                        "host": True,
-                        "url": True,
-                        "bytesloaded": True,
-                        "speed": True,
-                        "eta": True,
-                        "finished": True,
-                        "priority": True,
-                        "running": True,
-                        "skipped": True,
-                        "extractionStatus": True
-                    }]):
+    def query_links(
+        self,
+        params=[
+            {
+                "bytesTotal": True,
+                "comment": True,
+                "status": True,
+                "enabled": True,
+                "maxResults": -1,
+                "startAt": 0,
+                "packageUUIDs": [],
+                "host": True,
+                "url": True,
+                "bytesloaded": True,
+                "speed": True,
+                "eta": True,
+                "finished": True,
+                "priority": True,
+                "running": True,
+                "skipped": True,
+                "extractionStatus": True,
+            }
+        ],
+    ):
         """
         Get the links in the download list
         """
         resp = self.device.action(self.url + "/queryLinks", params)
         return resp
 
-    def query_packages(self,
-                       params=[{
-                           "bytesLoaded": True,
-                           "bytesTotal": True,
-                           "comment": True,
-                           "enabled": True,
-                           "eta": True,
-                           "priority": False,
-                           "finished": True,
-                           "running": True,
-                           "speed": True,
-                           "status": True,
-                           "childCount": True,
-                           "hosts": True,
-                           "saveTo": True,
-                           "maxResults": -1,
-                           "startAt": 0,
-                       }]):
+    def query_packages(
+        self,
+        params=[
+            {
+                "bytesLoaded": True,
+                "bytesTotal": True,
+                "comment": True,
+                "enabled": True,
+                "eta": True,
+                "priority": False,
+                "finished": True,
+                "running": True,
+                "speed": True,
+                "status": True,
+                "childCount": True,
+                "hosts": True,
+                "saveTo": True,
+                "maxResults": -1,
+                "startAt": 0,
+            }
+        ],
+    ):
         """
         Get the packages in the downloads list
         """
@@ -429,7 +438,7 @@ class Jddevice:
     """
 
     def __init__(self, jd, device_dict):
-        """ This functions initializates the device instance.
+        """This functions initializates the device instance.
         It uses the provided dictionary to create the device.
 
         :param device_dict: Device dictionary
@@ -451,12 +460,15 @@ class Jddevice:
         self.__direct_connection_consecutive_failures = 0
 
     def __refresh_direct_connections(self):
-        response = self.myjd.request_api("/device/getDirectConnectionInfos",
-                                         "POST", None, self.__action_url())
-        if response is not None \
-                and 'data' in response \
-                and 'infos' in response["data"] \
-                and len(response["data"]["infos"]) != 0:
+        response = self.myjd.request_api(
+            "/device/getDirectConnectionInfos", "POST", None, self.__action_url()
+        )
+        if (
+            response is not None
+            and "data" in response
+            and "infos" in response["data"]
+            and len(response["data"]["infos"]) != 0
+        ):
             self.__update_direct_connections(response["data"]["infos"])
 
     def __update_direct_connections(self, direct_info):
@@ -466,18 +478,18 @@ class Jddevice:
         tmp = []
         if self.__direct_connection_info is None:
             for conn in direct_info:
-                tmp.append({'conn': conn, 'cooldown': 0})
+                tmp.append({"conn": conn, "cooldown": 0})
             self.__direct_connection_info = tmp
             return
         #  We remove old connections not available anymore.
         for i in self.__direct_connection_info:
-            if i['conn'] not in direct_info:
+            if i["conn"] not in direct_info:
                 tmp.remove(i)
             else:
-                direct_info.remove(i['conn'])
+                direct_info.remove(i["conn"])
         # We add new connections
         for conn in direct_info:
-            tmp.append({'conn': conn, 'cooldown': 0})
+            tmp.append({"conn": conn, "cooldown": 0})
         self.__direct_connection_info = tmp
 
     def enable_direct_connection(self):
@@ -489,9 +501,16 @@ class Jddevice:
         self.__direct_connection_info = None
 
     def check_direct_connection(self):
-        if self.__direct_connection_enabled and self.__direct_connection_cooldown == 0 and self.__direct_connection_consecutive_failures == 0:
+        if (
+            self.__direct_connection_enabled
+            and self.__direct_connection_cooldown == 0
+            and self.__direct_connection_consecutive_failures == 0
+        ):
             if self.__direct_connection_info:
-                return {"status": True, "ip": self.__direct_connection_info[0]['conn']['ip']}
+                return {
+                    "status": True,
+                    "ip": self.__direct_connection_info[0]["conn"]["ip"],
+                }
         return {"status": False, "ip": None}
 
     def action(self, path, params=(), http_action="POST"):
@@ -505,60 +524,75 @@ class Jddevice:
         /example?param1=ex&param2=ex2 [("param1","ex"),("param2","ex2")]
         """
         action_url = self.__action_url()
-        if not self.__direct_connection_enabled or self.__direct_connection_info is None \
-                or time.time() < self.__direct_connection_cooldown:
+        if (
+            not self.__direct_connection_enabled
+            or self.__direct_connection_info is None
+            or time.time() < self.__direct_connection_cooldown
+        ):
             # No direct connection available, we use My.JDownloader api.
-            response = self.myjd.request_api(path, http_action, params,
-                                             action_url)
+            response = self.myjd.request_api(path, http_action, params, action_url)
             if response is None:
                 # My.JDownloader Api failed too.
                 return False
             else:
                 # My.JDownloader Api worked, lets refresh the direct connections and return
                 # the response.
-                if self.__direct_connection_enabled \
-                        and time.time() >= self.__direct_connection_cooldown:
+                if (
+                    self.__direct_connection_enabled
+                    and time.time() >= self.__direct_connection_cooldown
+                ):
                     self.__refresh_direct_connections()
-                return response['data']
+                return response["data"]
         else:
             # Direct connection info available, we try to use it.
             for conn in self.__direct_connection_info[:]:
-                connection_ip = conn['conn']['ip']
+                connection_ip = conn["conn"]["ip"]
                 # prevent connection to internal docker ip
-                if time.time() > conn['cooldown']:
+                if time.time() > conn["cooldown"]:
                     # We can use the connection
-                    connection = conn['conn']
-                    api = "http://" + connection_ip + ":" + str(
-                        connection["port"])
+                    connection = conn["conn"]
+                    api = "http://" + connection_ip + ":" + str(connection["port"])
                     try:
-                        response = self.myjd.request_api(path, http_action, params,
-                                                         action_url, api, timeout=3, output_errors=False)
-                    except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                        response = self.myjd.request_api(
+                            path,
+                            http_action,
+                            params,
+                            action_url,
+                            api,
+                            timeout=3,
+                            output_errors=False,
+                        )
+                    except (
+                        TokenExpiredException,
+                        RequestTimeoutException,
+                        MYJDException,
+                    ):
                         response = None
                     if response is not None:
                         # This connection worked so we push it to the top of the list.
                         self.__direct_connection_info.remove(conn)
                         self.__direct_connection_info.insert(0, conn)
                         self.__direct_connection_consecutive_failures = 0
-                        return response['data']
+                        return response["data"]
                     else:
                         # We don't try to use this connection for an hour.
-                        conn['cooldown'] = time.time() + 3600
+                        conn["cooldown"] = time.time() + 3600
                         self.__direct_connection_info.remove(conn)
                         self.__direct_connection_info.append(conn)
             # None of the direct connections worked, we set a cooldown for direct connections
             self.__direct_connection_consecutive_failures += 1
-            self.__direct_connection_cooldown = time.time() + (60 * self.__direct_connection_consecutive_failures)
+            self.__direct_connection_cooldown = time.time() + (
+                60 * self.__direct_connection_consecutive_failures
+            )
             # None of the direct connections worked, we use the My.JDownloader api
-            response = self.myjd.request_api(path, http_action, params,
-                                             action_url)
+            response = self.myjd.request_api(path, http_action, params, action_url)
             if response is None:
                 # My.JDownloader Api failed too.
                 return False
             # My.JDownloader Api worked, lets refresh the direct connections and return
             # the response.
             self.__refresh_direct_connections()
-            return response['data']
+            return response["data"]
 
     def __action_url(self):
         return "/t_" + self.myjd.get_session_token() + "_" + self.device_id
@@ -569,6 +603,7 @@ class Myjdapi:
     Main class for connecting to JD API.
 
     """
+
     # Class variable to track connection failures across all instances
     _connection_failed_at = None
 
@@ -616,9 +651,11 @@ class Myjdapi:
 
         """
         secret_hash = hashlib.sha256()
-        secret_hash.update(email.lower().encode('utf-8')
-                           + password.encode('utf-8')
-                           + domain.lower().encode('utf-8'))
+        secret_hash.update(
+            email.lower().encode("utf-8")
+            + password.encode("utf-8")
+            + domain.lower().encode("utf-8")
+        )
         return secret_hash.digest()
 
     def __update_encryption_tokens(self):
@@ -634,8 +671,7 @@ class Myjdapi:
         new_token.update(old_token + bytearray.fromhex(self.__session_token))
         self.__server_encryption_token = new_token.digest()
         new_token = hashlib.sha256()
-        new_token.update(self.__device_secret +
-                         bytearray.fromhex(self.__session_token))
+        new_token.update(self.__device_secret + bytearray.fromhex(self.__session_token))
         self.__device_encryption_token = new_token.digest()
 
     def __signature_create(self, key, data):
@@ -645,7 +681,7 @@ class Myjdapi:
         :param key:
         :param data:
         """
-        signature = hmac.new(key, data.encode('utf-8'), hashlib.sha256)
+        signature = hmac.new(key, data.encode("utf-8"), hashlib.sha256)
         return signature.hexdigest()
 
     def __decrypt(self, secret_token, data):
@@ -656,14 +692,12 @@ class Myjdapi:
         :param data:
         """
         init_vector = secret_token[: len(secret_token) // 2]
-        key = secret_token[len(secret_token) // 2:]
+        key = secret_token[len(secret_token) // 2 :]
         decryptor = AES.new(key, AES.MODE_CBC, init_vector)
         try:
             decrypted_data = unpad(decryptor.decrypt(self.__base64_decode(data)))
         except:
-            raise MYJDException(
-                "Failed to decode response: {}", data
-            )
+            raise MYJDException("Failed to decode response: {}", data)
 
         return decrypted_data
 
@@ -689,12 +723,12 @@ class Myjdapi:
         :param secret_token:
         :param data:
         """
-        data = pad(data.encode('utf-8'))
-        init_vector = secret_token[:len(secret_token) // 2]
-        key = secret_token[len(secret_token) // 2:]
+        data = pad(data.encode("utf-8"))
+        init_vector = secret_token[: len(secret_token) // 2]
+        key = secret_token[len(secret_token) // 2 :]
         encryptor = AES.new(key, AES.MODE_CBC, init_vector)
         encrypted_data = base64.b64encode(encryptor.encrypt(data))
-        return encrypted_data.decode('utf-8')
+        return encrypted_data.decode("utf-8")
 
     def update_request_id(self):
         """
@@ -731,13 +765,15 @@ class Myjdapi:
 
         self.__login_secret = self.__secret_create(email, password, "server")
         self.__device_secret = self.__secret_create(email, password, "device")
-        response = self.request_api("/my/connect", "GET", [("email", email),
-                                                           ("appkey",
-                                                            self.__app_key)])
+        response = self.request_api(
+            "/my/connect", "GET", [("email", email), ("appkey", self.__app_key)]
+        )
 
         if response is None:
             # Log and set failure timestamp
-            info("JDownloader API is currently unavailable! Stopping connection attempts for 5 minutes.")
+            info(
+                "JDownloader API is currently unavailable! Stopping connection attempts for 5 minutes."
+            )
             Myjdapi._connection_failed_at = time.time()
             return False
 
@@ -757,8 +793,9 @@ class Myjdapi:
 
         :returns: boolean -- True if successful, False if there was any error.
         """
-        response = self.request_api("/my/listdevices", "GET",
-                                    [("sessiontoken", self.__session_token)])
+        response = self.request_api(
+            "/my/listdevices", "GET", [("sessiontoken", self.__session_token)]
+        )
         self.update_request_id()
         self.__devices = response["list"]
 
@@ -796,14 +833,16 @@ class Myjdapi:
                     return Jddevice(self, device)
         raise (MYJDException("Device not found\n"))
 
-    def request_api(self,
-                    path,
-                    http_method="GET",
-                    params=None,
-                    action=None,
-                    api=None,
-                    timeout=30,
-                    output_errors=True):
+    def request_api(
+        self,
+        path,
+        http_method="GET",
+        params=None,
+        action=None,
+        api=None,
+        timeout=30,
+        output_errors=True,
+    ):
         """
         Makes a request to the API to the 'path' using the 'http_method' with parameters,'params'.
         Ex:
@@ -830,28 +869,39 @@ class Myjdapi:
             if self.__server_encryption_token is None:
                 query += [
                     "signature="
-                    + str(self.__signature_create(self.__login_secret,
-                                                  query[0] + "&".join(query[1:])))
+                    + str(
+                        self.__signature_create(
+                            self.__login_secret, query[0] + "&".join(query[1:])
+                        )
+                    )
                 ]
             else:
                 query += [
                     "signature="
-                    + str(self.__signature_create(self.__server_encryption_token,
-                                                  query[0] + "&".join(query[1:])))
+                    + str(
+                        self.__signature_create(
+                            self.__server_encryption_token,
+                            query[0] + "&".join(query[1:]),
+                        )
+                    )
                 ]
             query = query[0] + "&".join(query[1:])
 
-            headers = {
-                "User-Agent": f"Quasarr/{get_version()}"
-            }
+            headers = {"User-Agent": f"Quasarr/{get_version()}"}
             try:
-                encrypted_response = requests.get(api + query, timeout=timeout, headers=headers)
+                encrypted_response = requests.get(
+                    api + query, timeout=timeout, headers=headers
+                )
             except requests.exceptions.ConnectionError:
                 return None
             except Exception:
                 try:
-                    encrypted_response = requests.get(api + query, timeout=timeout, headers=headers, verify=False)
-                    debug("Could not establish secure connection to JDownloader. Is your time / timezone correct?")
+                    encrypted_response = requests.get(
+                        api + query, timeout=timeout, headers=headers, verify=False
+                    )
+                    debug(
+                        "Could not establish secure connection to JDownloader. Is your time / timezone correct?"
+                    )
                 except requests.exceptions.ConnectionError:
                     return None
                 except Exception:
@@ -868,14 +918,13 @@ class Myjdapi:
                 "apiVer": self.__api_version,
                 "url": path,
                 "params": params_request,
-                "rid": self.__request_id
+                "rid": self.__request_id,
             }
             data = json.dumps(params_request)
             # Removing quotes around null elements.
             data = data.replace('"null"', "null")
             data = data.replace("'null'", "null")
-            encrypted_data = self.__encrypt(self.__device_encryption_token,
-                                            data)
+            encrypted_data = self.__encrypt(self.__device_encryption_token, data)
             if action is not None:
                 request_url = api + action + path
             else:
@@ -885,10 +934,10 @@ class Myjdapi:
                     request_url,
                     headers={
                         "Content-Type": "application/aesjson-jd; charset=utf-8",
-                        "User-Agent": f"Quasarr/{get_version()}"
+                        "User-Agent": f"Quasarr/{get_version()}",
                     },
                     data=encrypted_data,
-                    timeout=timeout
+                    timeout=timeout,
                 )
             except requests.exceptions.ConnectionError:
                 return None
@@ -898,13 +947,15 @@ class Myjdapi:
                         request_url,
                         headers={
                             "Content-Type": "application/aesjson-jd; charset=utf-8",
-                            "User-Agent": f"Quasarr/{get_version()}"
+                            "User-Agent": f"Quasarr/{get_version()}",
                         },
                         data=encrypted_data,
                         timeout=timeout,
-                        verify=False
+                        verify=False,
+                    )
+                    debug(
+                        "Could not establish secure connection to JDownloader. Is your time / timezone correct?"
                     )
-                    debug("Could not establish secure connection to JDownloader. Is your time / timezone correct?")
                 except requests.exceptions.ConnectionError:
                     return None
                 except Exception:
@@ -918,12 +969,24 @@ class Myjdapi:
                 error_msg = json.loads(encrypted_response.text)
             except:
                 try:
-                    error_msg = json.loads(self.__decrypt(self.__device_encryption_token, encrypted_response.text))
+                    error_msg = json.loads(
+                        self.__decrypt(
+                            self.__device_encryption_token, encrypted_response.text
+                        )
+                    )
                 except:
-                    raise MYJDException("Failed to decode response: {}", encrypted_response.text)
-            msg = "\n\tSOURCE: " + error_msg["src"] + "\n\tTYPE: " + \
-                  error_msg["type"] + "\n------\nREQUEST_URL: " + \
-                  api + path
+                    raise MYJDException(
+                        "Failed to decode response: {}", encrypted_response.text
+                    )
+            msg = (
+                "\n\tSOURCE: "
+                + error_msg["src"]
+                + "\n\tTYPE: "
+                + error_msg["type"]
+                + "\n------\nREQUEST_URL: "
+                + api
+                + path
+            )
             if http_method == "GET":
                 msg += query
             msg += "\n"
@@ -932,16 +995,17 @@ class Myjdapi:
             raise (MYJDException(msg))
         if action is None:
             if not self.__server_encryption_token:
-                response = self.__decrypt(self.__login_secret,
-                                          encrypted_response.text)
+                response = self.__decrypt(self.__login_secret, encrypted_response.text)
             else:
-                response = self.__decrypt(self.__server_encryption_token,
-                                          encrypted_response.text)
+                response = self.__decrypt(
+                    self.__server_encryption_token, encrypted_response.text
+                )
         else:
-            response = self.__decrypt(self.__device_encryption_token,
-                                      encrypted_response.text)
-        jsondata = json.loads(response.decode('utf-8'))
-        if jsondata['rid'] != self.__request_id:
+            response = self.__decrypt(
+                self.__device_encryption_token, encrypted_response.text
+            )
+        jsondata = json.loads(response.decode("utf-8"))
+        if jsondata["rid"] != self.__request_id:
             self.update_request_id()
             return None
         self.update_request_id()