Adjust logging and examples; add pylint check (#144)

Author: btschwertfeger

.pre-commit-config.yaml

@@ -49,6 +49,16 @@ repos:
           - --select=E9,F63,F7,F82
           - --show-source
           - --statistics
+  - repo: https://github.com/pycqa/pylint
+    rev: v2.17.0
+    hooks:
+      - id: pylint
+        name: pylint
+        types: [python]
+        exclude: ^examples/|^tests/|^setup.py$
+        args:
+          - --rcfile=pyproject.toml
+          - -d=R0801 # ignore duplicate code
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.0.282
     hooks:

docs/conf.py

@@ -17,7 +17,7 @@
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = "python-kraken-sdk"
-copyright = "2023, Benjamin Thomas Schwertfeger"  # noqa: A001
+copyright = "2023, Benjamin Thomas Schwertfeger"  # noqa: A001 # pylint: disable=redefined-builtin
 author = "Benjamin Thomas Schwertfeger"
 
 # to import the package

examples/futures_ws_examples.py

@@ -67,30 +67,31 @@ async def on_message(self: "Client", msg: Union[list, dict]) -> None:
     # ...
 
     # _____Private_Websocket_Feeds_________________
-    client_auth = Client(key=key, secret=secret)
-    # print(client_auth.get_available_private_subscription_feeds())
-
-    # subscribe to a private/authenticated websocket feed
-    await client_auth.subscribe(feed="fills")
-    await client_auth.subscribe(feed="open_positions")
-    # await client_auth.subscribe(feed='open_orders')
-    # await client_auth.subscribe(feed='open_orders_verbose')
-    # await client_auth.subscribe(feed='deposits_withdrawals')
-    # await client_auth.subscribe(feed='account_balances_and_margins')
-    # await client_auth.subscribe(feed='balances')
-    # await client_auth.subscribe(feed='account_log')
-    # await client_auth.subscribe(feed='notifications_auth')
-
-    # authenticated clients can also subscribe to public feeds
-    # await client_auth.subscribe(feed='ticker', products=['PI_XBTUSD', 'PF_ETHUSD'])
-
-    # time.sleep(1)
-    # unsubscribe from a private/authenticated websocket feed
-    await client_auth.unsubscribe(feed="fills")
-    await client_auth.unsubscribe(feed="open_positions")
-    # ...
-
-    while not client.exception_occur and not client_auth.exception_occur:
+    if key and secret:
+        client_auth = Client(key=key, secret=secret)
+        # print(client_auth.get_available_private_subscription_feeds())
+
+        # subscribe to a private/authenticated websocket feed
+        await client_auth.subscribe(feed="fills")
+        await client_auth.subscribe(feed="open_positions")
+        # await client_auth.subscribe(feed='open_orders')
+        # await client_auth.subscribe(feed='open_orders_verbose')
+        # await client_auth.subscribe(feed='deposits_withdrawals')
+        # await client_auth.subscribe(feed='account_balances_and_margins')
+        # await client_auth.subscribe(feed='balances')
+        # await client_auth.subscribe(feed='account_log')
+        # await client_auth.subscribe(feed='notifications_auth')
+
+        # authenticated clients can also subscribe to public feeds
+        # await client_auth.subscribe(feed='ticker', products=['PI_XBTUSD', 'PF_ETHUSD'])
+
+        # time.sleep(1)
+        # unsubscribe from a private/authenticated websocket feed
+        await client_auth.unsubscribe(feed="fills")
+        await client_auth.unsubscribe(feed="open_positions")
+        # ...
+
+    while not client.exception_occur:  # and not client_auth.exception_occur:
         await asyncio.sleep(6)
 
 

examples/spot_trading_bot_template_v2.py

@@ -5,7 +5,7 @@
 
 """
 Module that provides a template to build a Spot trading algorithm using the
-python-kraken-sdk and Kraken Spot websocket API v1.
+python-kraken-sdk and Kraken Spot websocket API v2.
 """
 
 from __future__ import annotations

examples/spot_ws_examples_v1.py

@@ -82,18 +82,19 @@ async def on_message(self: Client, message: Union[list, dict]) -> None:
     await client.unsubscribe(subscription={"name": "spread"}, pair=["DOT/USD"])
     # ...
 
-    client_auth = Client(key=key, secret=secret)
-    # print(client_auth.active_private_subscriptions)
-    # print(client_auth.private_channel_names) # list private channel names
-    # when using the authenticated client, you can also subscribe to public feeds
-    await client_auth.subscribe(subscription={"name": "ownTrades"})
-    await client_auth.subscribe(subscription={"name": "openOrders"})
-
-    await asyncio.sleep(2)
-    await client_auth.unsubscribe(subscription={"name": "ownTrades"})
-    await client_auth.unsubscribe(subscription={"name": "openOrders"})
-
-    while not client.exception_occur and not client_auth.exception_occur:
+    if key and secret:
+        client_auth = Client(key=key, secret=secret)
+        # print(client_auth.active_private_subscriptions)
+        # print(client_auth.private_channel_names) # list private channel names
+        # when using the authenticated client, you can also subscribe to public feeds
+        await client_auth.subscribe(subscription={"name": "ownTrades"})
+        await client_auth.subscribe(subscription={"name": "openOrders"})
+
+        await asyncio.sleep(2)
+        await client_auth.unsubscribe(subscription={"name": "ownTrades"})
+        await client_auth.unsubscribe(subscription={"name": "openOrders"})
+
+    while not client.exception_occur:  # and not client_auth.exception_occur:
         await asyncio.sleep(6)
 
 

examples/spot_ws_examples_v2.py

@@ -90,19 +90,20 @@ async def on_message(self: Client, message: dict) -> None:
     )
     # ...
 
-    # Per default, the authenticated client starts two websocket connections,
-    # one for authenticated and one for public messages. If there is no need
-    # for a public connection, it can be disabled using the ``no_public``
-    # parameter.
-    client_auth = Client(key=key, secret=secret, no_public=True)
-    # print(client_auth.private_channel_names)  # … list private channel names
-    # when using the authenticated client, you can also subscribe to public feeds
-    await client_auth.subscribe(params={"channel": "executions"})
-
-    await asyncio.sleep(5)
-    await client_auth.unsubscribe(params={"channel": "executions"})
-
-    while not client.exception_occur and not client_auth.exception_occur:
+    if key and secret:
+        # Per default, the authenticated client starts two websocket connections,
+        # one for authenticated and one for public messages. If there is no need
+        # for a public connection, it can be disabled using the ``no_public``
+        # parameter.
+        client_auth = Client(key=key, secret=secret, no_public=True)
+        # print(client_auth.private_channel_names)  # … list private channel names
+        # when using the authenticated client, you can also subscribe to public feeds
+        await client_auth.subscribe(params={"channel": "executions"})
+
+        await asyncio.sleep(5)
+        await client_auth.unsubscribe(params={"channel": "executions"})
+
+    while not client.exception_occur:  # and not client_auth.exception_occur:
         await asyncio.sleep(6)
 
 

kraken/futures/user.py

@@ -10,11 +10,11 @@
 
 from typing import TYPE_CHECKING, Optional, Union
 
+from kraken.base_api import KrakenBaseFuturesAPI, defined
+
 if TYPE_CHECKING:
     import requests
 
-from kraken.base_api import KrakenBaseFuturesAPI, defined
-
 
 class User(KrakenBaseFuturesAPI):
     """

kraken/futures/websocket/__init__.py

@@ -21,7 +21,6 @@
 from kraken.exceptions import KrakenException
 
 if TYPE_CHECKING:
-    # to avoid circular import for type checking
     from kraken.futures import KrakenFuturesWSClient
 
 
@@ -89,10 +88,10 @@ async def __run(self: ConnectFuturesWebsocket, event: asyncio.Event) -> None:
                 try:
                     _msg = await asyncio.wait_for(self.__socket.recv(), timeout=15)
                 except asyncio.TimeoutError:
-                    logging.debug(
-                        "Timeout error in {endpoint}",
-                        extra={"endpoint": self.__ws_endpoint},
-                    )  # important
+                    logging.debug(  # important
+                        "Timeout error in %s",
+                        self.__ws_endpoint,
+                    )
                 except asyncio.CancelledError:
                     logging.exception("asyncio.CancelledError")
                     keep_alive = False
@@ -138,8 +137,9 @@ async def __reconnect(self: ConnectFuturesWebsocket) -> None:
 
         reconnect_wait: float = self.__get_reconnect_wait(self.__reconnect_num)
         logging.debug(
-            "asyncio sleep reconnect_wait={wait} s reconnect_num={num}",
-            extra={"wait": reconnect_wait, "num": self.__reconnect_num},
+            "asyncio sleep reconnect_wait=%f s reconnect_num=%d",
+            reconnect_wait,
+            self.__reconnect_num,
         )
         await asyncio.sleep(reconnect_wait)
         logging.debug("asyncio sleep done")
@@ -165,7 +165,7 @@ async def __reconnect(self: ConnectFuturesWebsocket) -> None:
                     message = f"{task} got an exception {task.exception()}\n {task.get_stack()}"
                     logging.warning(message)
                     for process in pending:
-                        logging.warning("pending {proc}", extra={"proc": process})
+                        logging.warning("pending %s", process)
                         try:
                             process.cancel()
                         except asyncio.CancelledError:
@@ -181,8 +181,8 @@ async def __recover_subscription_req_msg(
         event: asyncio.Event,
     ) -> None:
         logging.info(
-            "Recover subscriptions {subscriptions} waiting.",
-            extra={"subscriptions": self.__subscriptions},
+            "Recover subscriptions %s waiting.",
+            self.__subscriptions,
         )
         await event.wait()
 
@@ -191,11 +191,11 @@ async def __recover_subscription_req_msg(
                 await self.send_message(deepcopy(sub), private=True)
             elif sub["feed"] in self.__client.get_available_public_subscription_feeds():
                 await self.send_message(deepcopy(sub), private=False)
-            logging.info("{sub}: OK", extra={"sub": sub})
+            logging.info("%s: OK", sub)
 
         logging.info(
-            "Recover subscriptions {subscriptions} done.",
-            extra={"subscriptions": self.__subscriptions},
+            "Recover subscriptions %s done.",
+            self.__subscriptions,
         )
 
     async def send_message(

kraken/spot/orderbook.py

@@ -306,8 +306,8 @@ async def on_book_update(
                     message: list
                 ) -> None:
                     book: Dict[str, Any] = self.get(pair="XBT/USD")
-                    ask: List[Tuple[str, str]] = list(book["ask"].items())
-                    bid: List[Tuple[str, str]] = list(book["bid"].items())
+                    ask: list[Tuple[str, str]] = list(book["ask"].items())
+                    bid: list[Tuple[str, str]] = list(book["bid"].items())
                     # ask and bid are now in format [price, (volume, timestamp)]
                     # … and include the whole orderbook
         """

kraken/spot/websocket/connectors.py

@@ -108,8 +108,8 @@ async def __run(self: ConnectSpotWebsocketBase, event: asyncio.Event) -> None:
             None if not self.__is_auth else self.__client.get_ws_token()
         )
         self.LOG.debug(
-            "Websocket token: {details}",
-            extra={"details": self.ws_conn_details},
+            "Websocket token: %s",
+            self.ws_conn_details,
         )
 
         async with websockets.connect(  # pylint: disable=no-member
@@ -162,8 +162,9 @@ async def __run_forever(self: ConnectSpotWebsocketBase) -> None:
         except Exception as exc:
             traceback_: str = traceback.format_exc()
             logging.exception(
-                "{exc}: {traceback}",
-                extra={"exc": exc, "traceback": traceback_},
+                "%s: %s",
+                exc,
+                traceback_,
             )
             await self.__callback({"error": traceback_})
         finally:
@@ -215,7 +216,7 @@ async def __reconnect(self: ConnectSpotWebsocketBase) -> None:
                     message: str = f"{task} got an exception {task.exception()}\n {task.get_stack()}"
                     self.LOG.warning(message)
                     for process in pending:
-                        self.LOG.warning("pending {proc}", extra={"proc": process})
+                        self.LOG.warning("pending %s", process)
                         try:
                             process.cancel()
                         except asyncio.CancelledError:
@@ -355,7 +356,7 @@ async def _recover_subscriptions(
                 private = True
 
             await self.client.send_message(cpy, private=private)
-            self.LOG.info("{sub} OK", extra={"sub": sub})
+            self.LOG.info("%s: OK", sub)
 
         self.LOG.info("%s done.", log_msg)
 
@@ -500,7 +501,7 @@ async def _recover_subscriptions(
 
         for subscription in self._subscriptions:
             await self.client.subscribe(params=subscription)
-            self.LOG.info("{subscription} OK", extra={"subscription": subscription})
+            self.LOG.info("%s: OK", subscription)
 
         self.LOG.info("%s done.", log_msg)