progress. not ready, changing live_strategy.py to use ExchangeInstrument and new TradingInstruction class

lib/cvtt_client/mkt_data.py

@@ -10,10 +10,12 @@ import uuid
 from dataclasses import dataclass
 from typing import Callable, Coroutine, Dict, List, Optional
 
-from numpy.strings import str_len
 import websockets
 from websockets.asyncio.client import ClientConnection
 
+from cvttpy_base.settings.cvtt_types import JsonDictT
+from cvttpy_base.tools.logger import Log
+
 MessageTypeT = str
 SubscriptionIdT = str
 MessageT = Dict
@@ -48,22 +50,56 @@ class CvttPricesSubscription:
         self.is_subscribed_ = False
         self.is_historical_ = history_depth_sec > 0
 
-
-class CvttPricerWebSockClient:
-    # Class members with type hints
+class CvttWebSockClient:
     ws_url_: UrlT
     websocket_: Optional[ClientConnection]
-    subscriptions_: Dict[SubscriptionIdT, CvttPricesSubscription]
     is_connected_: bool
-    logger_: logging.Logger
-
+    
     def __init__(self, url: str):
         self.ws_url_ = url
         self.websocket_ = None
         self.is_connected_ = False
+
+    async def connect(self) -> None:
+        self.websocket_ = await websockets.connect(self.ws_url_)
+        self.is_connected_ = True
+
+    async def close(self) -> None:
+        if self.websocket_ is not None:
+            await self.websocket_.close()
+            self.is_connected_ = False
+
+    async def receive_message(self) -> JsonDictT:
+        assert self.websocket_ is not None
+        assert self.is_connected_
+        message = await self.websocket_.recv()
+        message_str = (
+            message.decode("utf-8")
+            if isinstance(message, bytes)
+            else message
+        )
+        res = json.loads(message_str)
+        assert res is not None
+        assert isinstance(res, dict)
+        return res
+    
+    @classmethod
+    async def check_connection(cls, url: str) -> bool:
+        try:
+            async with websockets.connect(url) as websocket:
+                result = True
+        except Exception as e:
+            Log.error(f"Unable to connect to {url}: {str(e)}")
+            result = False
+        return result
+    
+class CvttPricerWebSockClient(CvttWebSockClient):
+    # Class members with type hints
+    subscriptions_: Dict[SubscriptionIdT, CvttPricesSubscription]
+
+    def __init__(self, url: str):
+        super().__init__(url)
         self.subscriptions_ = {}
-        self.logger_ = logging.getLogger(__name__)
-        logging.basicConfig(level=logging.INFO)
 
     async def subscribe(
         self, subscription: CvttPricesSubscription
@@ -71,11 +107,10 @@ class CvttPricerWebSockClient:
 
         if not self.is_connected_:
             try:
-                self.logger_.info(f"Connecting to {self.ws_url_}")
-                self.websocket_ = await websockets.connect(self.ws_url_)
-                self.is_connected_ = True
+                Log.info(f"Connecting to {self.ws_url_}")
+                await self.connect()
             except Exception as e:
-                self.logger_.error(f"Unable to connect to {self.ws_url_}: {str(e)}")
+                Log.error(f"Unable to connect to {self.ws_url_}: {str(e)}")
                 raise e
 
         subscr_msg = {
@@ -109,10 +144,10 @@ class CvttPricerWebSockClient:
             return False
 
         if response.get("status") == "success":
-            self.logger_.info(f"Subscription successful: {json.dumps(response)}")
+            Log.info(f"Subscription successful: {json.dumps(response)}")
             return True
         elif response.get("status") == "error":
-            self.logger_.error(f"Subscription failed: {response.get('reason')}")
+            Log.error(f"Subscription failed: {response.get('reason')}")
             return False
         return False
 
@@ -121,19 +156,20 @@ class CvttPricerWebSockClient:
         try:
             while self.is_connected_:
                 try:
-                    message = await self.websocket_.recv()
-                    message_str = (
-                        message.decode("utf-8")
-                        if isinstance(message, bytes)
-                        else message
-                    )
-                    await self.process_message(json.loads(message_str))
+                    msg_dict: JsonDictT = await self.receive_message()
                 except websockets.ConnectionClosed:
-                    self.logger_.warning("Connection closed")
+                    Log.warning("Connection closed")
                     self.is_connected_ = False
                     break
+                except Exception as e:
+                    Log.error(f"Error occurred: {str(e)}")
+                    self.is_connected_ = False
+                    await asyncio.sleep(5)  # Wait before reconnecting
+
+                await self.process_message(msg_dict)
+
         except Exception as e:
-            self.logger_.error(f"Error occurred: {str(e)}")
+            Log.error(f"Error occurred: {str(e)}")
             self.is_connected_ = False
             await asyncio.sleep(5)  # Wait before reconnecting
 
@@ -142,13 +178,13 @@ class CvttPricerWebSockClient:
         if message_type in ["md_aggregate", "historical_md_aggregate"]:
             subscription_id = message.get("subscr_id")
             if subscription_id not in self.subscriptions_:
-                self.logger_.warning(f"Unknown subscription id: {subscription_id}")
+                Log.warning(f"Unknown subscription id: {subscription_id}")
                 return
 
             subscription = self.subscriptions_[subscription_id]
             await subscription.callback_(message_type, subscription_id, message)
         else:
-            self.logger_.warning(f"Unknown message type: {message.get('type')}")
+            Log.warning(f"Unknown message type: {message.get('type')}")
 
 
 async def main() -> None: