Disable custom Kraken exceptions (optional) (#82)

# Summary
The custom Kraken exceptions can be disabled when passing
`use_custom_exceptions=False` during Spot and Futures REST client
instantiation.

Author: btschwertfeger

CHANGELOG.md

@@ -10,6 +10,12 @@
 - Add API rate limit exception; extend test doc strings [\#79](https://github.com/btschwertfeger/python-kraken-sdk/pull/79) ([btschwertfeger](https://github.com/btschwertfeger))
 - Fix bug/typo: "recend" -\> recent throughout kraken.spot [\#76](https://github.com/btschwertfeger/python-kraken-sdk/pull/76) ([jcr-jeff](https://github.com/jcr-jeff))
 
+**Implemented enhancements:**
+
+- Enable trading on Futures subaccount [\#72](https://github.com/btschwertfeger/python-kraken-sdk/issues/72)
+- Check if trading is enabled for Futures subaccount [\#71](https://github.com/btschwertfeger/python-kraken-sdk/issues/71)
+- Add Futures user endpoints: `check_trading_enabled_on_subaccount` and `set_trading_on_subaccount` [\#80](https://github.com/btschwertfeger/python-kraken-sdk/pull/80) ([btschwertfeger](https://github.com/btschwertfeger))
+
 **Fixed bugs:**
 
 - Release workflow skips the PyPI publish [\#67](https://github.com/btschwertfeger/python-kraken-sdk/issues/67)

Makefile

@@ -79,10 +79,12 @@ clean:
 		python_kraken_sdk.egg-info \
 		docs/_build \
 		.vscode
+
 	rm -f .coverage coverage.xml pytest.xml \
 		kraken/_version.py \
 		*.log *.csv *.zip \
-		tests/*.zip tests/.csv
+		tests/*.zip tests/.csv \
+		python_kraken_sdk-*.whl
 
 	find tests -name "__pycache__" | xargs rm -rf
 	find kraken -name "__pycache__" | xargs rm -rf

kraken/base_api/__init__.py

@@ -13,7 +13,7 @@
 from typing import List, Union
 from uuid import uuid1
 
-from requests import Response, Session
+import requests
 
 from kraken.exceptions import KrakenException
 
@@ -113,7 +113,12 @@ class KrakenBaseSpotAPI:
     API_V = "/0"
 
     def __init__(
-        self, key: str = "", secret: str = "", url: str = "", sandbox: bool = False
+        self,
+        key: str = "",
+        secret: str = "",
+        url: str = "",
+        sandbox: bool = False,
+        use_custom_exceptions: bool = True,
     ):
         if sandbox:
             raise ValueError("Sandbox not available for Kraken Spot trading.")
@@ -122,11 +127,13 @@ def __init__(
         else:
             self.url = self.URL
 
-        self.__nonce = 0
-        self.__key = key
-        self.__secret = secret
-        self.__err_handler = KrakenErrorHandler()
-        self.__session = Session()
+        self.__nonce: int = 0
+        self.__key: str = key
+        self.__secret: str = secret
+        self.__use_custom_exceptions: bool = use_custom_exceptions
+
+        self.__err_handler: KrakenErrorHandler = KrakenErrorHandler()
+        self.__session: requests.Session = requests.Session()
         self.__session.headers.update({"User-Agent": "python-kraken-sdk"})
 
     def _request(
@@ -163,16 +170,17 @@ def _request(
         :rtype: dict
         """
         if params is None:
-            params = {}
-        method = method.upper()
-        data_json = ""
+            params: dict = {}
+
+        method: str = method.upper()
+        data_json: str = ""
         if method in ("GET", "DELETE"):
             if params:
-                strl = [f"{key}={params[key]}" for key in sorted(params)]
-                data_json = "&".join(strl)
+                strl: List[str] = [f"{key}={params[key]}" for key in sorted(params)]
+                data_json: str = "&".join(strl)
                 uri += f"?{data_json}".replace(" ", "%20")
 
-        headers = {}
+        headers: dict = {}
         if auth:
             if (
                 not self.__key
@@ -193,7 +201,7 @@ def _request(
                 }
             )
 
-        url = f"{self.url}{self.API_V}{uri}"
+        url: str = f"{self.url}{self.API_V}{uri}"
         if method in ("GET", "DELETE"):
             return self.__check_response_data(
                 self.__session.request(
@@ -245,8 +253,8 @@ def _get_kraken_signature(self, urlpath: str, data: dict) -> str:
         ).decode()
 
     def __check_response_data(
-        self, response: Response, return_raw: bool = False
-    ) -> Union[dict, Response]:
+        self, response: requests.Response, return_raw: bool = False
+    ) -> Union[dict, requests.Response]:
         """
         Checkes the response, handles the error (if exists) and returns the response data.
 
@@ -257,6 +265,9 @@ def __check_response_data(
         :return: The reponse in raw or parsed to dict
         :rtype: Union[dict, requests.Response]
         """
+        if not self.__use_custom_exceptions:
+            return response
+
         if response.status_code in ("200", 200):
             if return_raw:
                 return response
@@ -321,22 +332,28 @@ class KrakenBaseFuturesAPI:
     SANDBOX_URL = "https://demo-futures.kraken.com"
 
     def __init__(
-        self, key: str = "", secret: str = "", url: str = "", sandbox: bool = False
+        self,
+        key: str = "",
+        secret: str = "",
+        url: str = "",
+        sandbox: bool = False,
+        use_custom_exceptions: bool = True,
     ):
-        self.sandbox = sandbox
+        self.sandbox: bool = sandbox
         if url:
-            self.url = url
+            self.url: str = url
         elif self.sandbox:
-            self.url = self.SANDBOX_URL
+            self.url: str = self.SANDBOX_URL
         else:
-            self.url = self.URL
+            self.url: str = self.URL
 
-        self.__key = key
-        self.__secret = secret
-        self.__nonce = 0
+        self.__key: str = key
+        self.__secret: str = secret
+        self.__nonce: int = 0
+        self.__use_custom_exceptions: bool = use_custom_exceptions
 
-        self.__err_handler = KrakenErrorHandler()
-        self.__session = Session()
+        self.__err_handler: KrakenErrorHandler = KrakenErrorHandler()
+        self.__session: requests.Session = requests.Session()
         self.__session.headers.update({"User-Agent": "python-kraken-sdk"})
 
     def _request(
@@ -368,33 +385,33 @@ def _request(
         :param do_json: If the ``post_params`` must be "jsonified" - in case of nested dict style
         :type do_json: bool
         :param return_raw: If the response should be returned without parsing.
-         This is used for example when requesting an export of the trade history as .zip archive.
+            This is used for example when requesting an export of the trade history as .zip archive.
         :type return_raw: bool
         :raise kraken.exceptions.KrakenException.*: If the response contains errors
         :return: The response
         :rtype: dict
         """
-        method = method.upper()
+        method: str = method.upper()
 
         post_string: str = ""
         if post_params is not None:
             strl: List[str] = [
                 f"{key}={post_params[key]}" for key in sorted(post_params)
             ]
-            post_string = "&".join(strl)
+            post_string: str = "&".join(strl)
         else:
-            post_params = {}
+            post_params: dict = {}
 
         query_string: str = ""
         if query_params is not None:
             strl: List[str] = [
                 f"{key}={query_params[key]}" for key in sorted(query_params)
             ]
-            query_string = "&".join(strl).replace(" ", "%20")
+            query_string: str = "&".join(strl).replace(" ", "%20")
         else:
-            query_params = {}
+            query_params: dict = {}
 
-        headers = {}
+        headers: dict = {}
         if auth:
             if (
                 not self.__key
@@ -403,8 +420,8 @@ def _request(
                 or self.__secret == ""
             ):
                 raise ValueError("Missing credentials")
-            self.__nonce = (self.__nonce + 1) % 1
-            nonce = str(int(time.time() * 1000)) + str(self.__nonce).zfill(4)
+            self.__nonce: int = (self.__nonce + 1) % 1
+            nonce: str = str(int(time.time() * 1000)) + str(self.__nonce).zfill(4)
             headers.update(
                 {
                     "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
@@ -480,8 +497,8 @@ def _get_kraken_futures_signature(
         )
 
     def __check_response_data(
-        self, response: Response, return_raw: bool = False
-    ) -> dict:
+        self, response: requests.Response, return_raw: bool = False
+    ) -> Union[dict, requests.Response]:
         """
         Checkes the response, handles the error (if exists) and returns the response data.
 
@@ -491,13 +508,16 @@ def __check_response_data(
         :type return_raw: dict
         :raise kraken.exceptions.KrakenException.*: If the response contains the error key
         :return: The signed string
-        :rtype: str
+        :rtype: Union[dict, Response]
         """
+        if not self.__use_custom_exceptions:
+            return response
+
         if response.status_code in ("200", 200):
             if return_raw:
                 return response
             try:
-                data = response.json()
+                data: dict = response.json()
             except ValueError as exc:
                 raise ValueError(response.content) from exc
 

kraken/exceptions/__init__.py

@@ -62,6 +62,7 @@ def __init__(self, msg=None, *args, **kwargs):
             ##
             "authenticationError": self.KrakenAuthenticationError,
             "insufficientAvailableFunds": self.KrakenInsufficientAvailableFundsError,
+            "requiredArgumentMissing": self.KrakenRequiredArgumentMissingError,
             "apiLimitExceeded": self.KrakenApiLimitExceededError,
             "invalidUnit": self.KrakenInvalidUnitError,
             "Unavailable": self.KrakenUnavailableError,
@@ -104,6 +105,10 @@ def wrapped_init(self, msg=None, *args, **kwargs):
     class KrakenInvalidArgumentsError(Exception):
         """The request payload is malformed, incorrect or ambiguous."""
 
+    @docstring_message
+    class KrakenRequiredArgumentMissingError(Exception):
+        """The request is missing a required argument."""
+
     @docstring_message
     class KrakenInvalidArgumentsIndexUnavailableError(Exception):
         """Index pricing is unavailable for stop/profit orders on this pair."""

tests/futures/test_futures_base_api.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023 Benjamin Thomas Schwertfeger
+# Github: https://github.com/btschwertfeger
+#
+
+"""Module that checks the general Futures Base API class."""
+
+
+import pytest
+
+from kraken.base_api import KrakenBaseFuturesAPI
+from kraken.exceptions import KrakenException
+
+
+@pytest.mark.futures
+def test_KrakenBaseFuturesAPI_without_exception() -> None:
+    """
+    Checks first if the expected error will be raised and than
+    creates a new KrakenBaseFuturesAPI instance that do not raise
+    the custom Kraken exceptions. This new instance thant executes
+    the same request and the returned response gets evaluated.
+    """
+    with pytest.raises(KrakenException.KrakenRequiredArgumentMissingError):
+        KrakenBaseFuturesAPI(
+            key="fake",
+            secret="fake",
+        )._request(method="POST", uri="/derivatives/api/v3/sendorder", auth=True)
+
+    result: dict = (
+        KrakenBaseFuturesAPI(key="fake", secret="fake", use_custom_exceptions=False)
+        ._request(method="POST", uri="/derivatives/api/v3/sendorder", auth=True)
+        .json()
+    )
+
+    assert (
+        result.get("result") == "error"
+        and result.get("error") == "requiredArgumentMissing"
+    )

tests/spot/test_spot_base_api.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023 Benjamin Thomas Schwertfeger
+# Github: https://github.com/btschwertfeger
+#
+
+"""Module that checks the general Spot Base API class."""
+
+import pytest
+
+from kraken.base_api import KrakenBaseSpotAPI
+from kraken.exceptions import KrakenException
+
+
+@pytest.mark.spot
+def test_KrakenBaseSpotAPI_without_exception() -> None:
+    """
+    Checks first if the expected error will be raised and than
+    creates a new KrakenBaseSpotAPI instance that do not raise
+    the custom Kraken exceptions. This new instance thant executes
+    the same request and the returned response gets evaluated.
+    """
+    with pytest.raises(KrakenException.KrakenInvalidAPIKeyError):
+        KrakenBaseSpotAPI(
+            key="fake",
+            secret="fake",
+        )._request(method="POST", uri="/private/AddOrder", auth=True)
+
+    assert KrakenBaseSpotAPI(
+        key="fake", secret="fake", use_custom_exceptions=False
+    )._request(method="POST", uri="/private/AddOrder", auth=True).json() == {
+        "error": ["EAPI:Invalid key"]
+    }