Resolve "163 uniform the msg parameter" (#164)

Author: btschwertfeger

examples/futures_trading_bot_template.py

@@ -64,9 +64,9 @@ def __init__(self: TradingBot, config: dict) -> None:
         self.__market: Market = Market(key=config["key"], secret=config["secret"])
         self.__funding: Funding = Funding(key=config["key"], secret=config["secret"])
 
-    async def on_message(self: TradingBot, msg: Union[list, dict]) -> None:
+    async def on_message(self: TradingBot, message: Union[list, dict]) -> None:
         """Receives all messages that came form the websocket feed(s)"""
-        logging.info(msg)
+        logging.info(message)
 
         # == apply your trading strategy here ==
 

examples/futures_ws_examples.py

@@ -39,9 +39,9 @@ async def main() -> None:
     class Client(KrakenFuturesWSClient):
         """Can be used to create a custom trading strategy"""
 
-        async def on_message(self: "Client", msg: Union[list, dict]) -> None:
+        async def on_message(self: Client, message: Union[list, dict]) -> None:
             """Receives the websocket messages"""
-            logging.info(msg)
+            logging.info(message)
             # … apply your trading strategy here
             # … you can also combine this with the Futures REST clients
 
@@ -106,8 +106,8 @@ async def on_message(self: "Client", msg: Union[list, dict]) -> None:
 # from kraken.futures import KrakenFuturesWSClient
 # import asyncio
 
-# async def on_message(msg):
-#     print(msg)
+# async def on_message(message):
+#     print(message)
 
 # async def main() -> None:
 #     async with KrakenFuturesWSClient(callback=on_message) as session:

examples/spot_ws_examples_v1.py

@@ -110,8 +110,8 @@ async def on_message(self: Client, message: Union[list, dict]) -> None:
 # from kraken.spot import KrakenSpotWSClientV1
 # import asyncio
 
-# async def on_message(msg):
-#     print(msg)
+# async def on_message(message):
+#     print(message)
 
 # async def main() -> None:
 #     async with KrakenSpotWSClientV1(callback=on_message) as session:

kraken/futures/websocket/__init__.py

@@ -86,7 +86,7 @@ async def __run(self: ConnectFuturesWebsocket, event: asyncio.Event) -> None:
 
             while keep_alive:
                 try:
-                    _msg = await asyncio.wait_for(self.__socket.recv(), timeout=15)
+                    _message = await asyncio.wait_for(self.__socket.recv(), timeout=15)
                 except asyncio.TimeoutError:
                     logging.debug(  # important
                         "Timeout error in %s",
@@ -98,9 +98,9 @@ async def __run(self: ConnectFuturesWebsocket, event: asyncio.Event) -> None:
                     await self.__callback({"error": "asyncio.CancelledError"})
                 else:
                     try:
-                        message: dict = json.loads(_msg)
+                        message: dict = json.loads(_message)
                     except ValueError:
-                        logging.warning(_msg)
+                        logging.warning(_message)
                     else:
                         forward: bool = True
                         if "event" in message:
@@ -200,15 +200,15 @@ async def __recover_subscription_req_msg(
 
     async def send_message(
         self: ConnectFuturesWebsocket,
-        msg: dict,
+        message: dict,
         *,
         private: bool = False,
     ) -> None:
         """
         Enables sending a message via the websocket connection
 
-        :param msg: The message as dictionary
-        :type msg: dict
+        :param message: The message as dictionary
+        :type message: dict
         :param private: If the message requires authentication (default: ``False``)
         :type private: bool, optional
         :rtype: Coroutine
@@ -224,14 +224,14 @@ async def send_message(
             if not self.__challenge_ready:
                 await self.__check_challenge_ready()
 
-            msg["api_key"] = self.__client.key
-            msg["original_challenge"] = self.__last_challenge
-            msg["signed_challenge"] = self.__new_challenge
+            message["api_key"] = self.__client.key
+            message["original_challenge"] = self.__last_challenge
+            message["signed_challenge"] = self.__new_challenge
 
-        await self.__socket.send(json.dumps(msg))
+        await self.__socket.send(json.dumps(message))
 
-    def __handle_new_challenge(self: ConnectFuturesWebsocket, msg: dict) -> None:
-        self.__last_challenge = msg["message"]
+    def __handle_new_challenge(self: ConnectFuturesWebsocket, message: dict) -> None:
+        self.__last_challenge = message["message"]
         self.__new_challenge = self.__client.get_sign_challenge(self.__last_challenge)
         self.__challenge_ready = True
 
@@ -249,13 +249,15 @@ def __get_reconnect_wait(self, attempts: int) -> float:
             random() * min(60 * 3, (2**attempts) - 1) + 1,  # noqa: S311
         )
 
-    def __append_subscription(self: ConnectFuturesWebsocket, msg: dict) -> None:
-        self.__remove_subscription(msg=msg)  # remove from list, to avoid duplicates
-        sub: dict = self.__build_subscription(msg)
+    def __append_subscription(self: ConnectFuturesWebsocket, message: dict) -> None:
+        self.__remove_subscription(
+            message=message,
+        )  # remove from list, to avoid duplicates
+        sub: dict = self.__build_subscription(message)
         self.__subscriptions.append(sub)
 
-    def __remove_subscription(self: ConnectFuturesWebsocket, msg: dict) -> None:
-        sub: dict = self.__build_subscription(msg)
+    def __remove_subscription(self: ConnectFuturesWebsocket, message: dict) -> None:
+        sub: dict = self.__build_subscription(message)
         self.__subscriptions = [x for x in self.__subscriptions if x != sub]
 
     def __build_subscription(

kraken/futures/ws_client.py

@@ -86,8 +86,8 @@ async def on_message(self, event: dict) -> None:
         import asyncio
         from kraken.futures import KrakenFuturesWSClient
 
-        async def on_message(msg):
-            print(msg)
+        async def on_messageessage):
+            print(message)
 
         async def main() -> None:
             async with KrakenFuturesWSClient(callback=on_message) as session:
@@ -164,24 +164,23 @@ def get_sign_challenge(self: KrakenFuturesWSClient, challenge: str) -> str:
             ).digest(),
         ).decode("utf-8")
 
-    async def on_message(self: KrakenFuturesWSClient, msg: dict) -> None:
+    async def on_message(self: KrakenFuturesWSClient, message: dict) -> None:
         """
         Method that serves as the default callback function Calls the defined callback function (if defined)
         or overload this function.
 
         This is the default method  which just logs the messages. In production you want to overload this
         with your custom methods, as shown in the Example of :class:`kraken.futures.KrakenFuturesWSClient`.
 
-        :param msg: The message that was send by Kraken via the websocket connection.
-        :type msg: dict
-        :rtype: NOne
+        :param message: The message that was send by Kraken via the websocket connection.
+        :type message: dict
+        :rtype: None
         """
-        # todo: rename the msg parameter to message
         if self.__callback is not None:
-            await self.__callback(msg)
+            await self.__callback(message)
         else:
             logging.warning("Received event but no callback is defined")
-            logging.info(msg)
+            logging.info(message)
 
     async def subscribe(
         self: KrakenFuturesWSClient,

kraken/spot/websocket/connectors.py

@@ -130,7 +130,7 @@ async def __run(self: ConnectSpotWebsocketBase, event: asyncio.Event) -> None:
                 if time() - self._last_ping > self.PING_INTERVAL:
                     await self.send_ping()
                 try:
-                    _msg = await asyncio.wait_for(self.socket.recv(), timeout=15)
+                    _message = await asyncio.wait_for(self.socket.recv(), timeout=15)
                 except asyncio.TimeoutError:  # important
                     await self.send_ping()
                 except asyncio.CancelledError:
@@ -139,9 +139,9 @@ async def __run(self: ConnectSpotWebsocketBase, event: asyncio.Event) -> None:
                     await self.__callback({"error": "asyncio.CancelledError"})
                 else:
                     try:
-                        message: dict = json.loads(_msg)
+                        message: dict = json.loads(_message)
                     except ValueError:
-                        self.LOG.warning(_msg)
+                        self.LOG.warning(_message)
                     else:
                         self.LOG.debug(message)
                         self._manage_subscriptions(message=message)

tests/futures/helper.py

@@ -55,13 +55,13 @@ def __init__(
 
     async def on_message(
         self: "FuturesWebsocketClientTestWrapper",
-        msg: Union[list, dict],
+        message: Union[list, dict],
     ) -> None:
         """
         This is the callback function that must be implemented
         to handle custom websocket messages.
         """
-        self.LOG.info(msg)  # the log is read within the tests
+        self.LOG.info(message)  # the log is read within the tests
 
         log: str = ""
         try:
@@ -71,4 +71,4 @@ async def on_message(
             pass
 
         with open("futures_ws.log", "w", encoding="utf-8") as logfile:
-            logfile.write(f"{log}\n{msg}")
+            logfile.write(f"{log}\n{message}")