wiz-trader 0.23.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

wiz_trader/__init__.py

@@ -3,6 +3,6 @@
 from .quotes import QuotesClient
 from .apis import WizzerClient
 
-__version__ = "0.23.0"
+__version__ = "0.24.0"
 
 __all__ = ["QuotesClient", "WizzerClient"]

wiz_trader/quotes/client.py

@@ -3,16 +3,11 @@ import json
 import os
 import logging
 import random
-from typing import Callable, List, Optional, Any, Iterator, Dict, Set, TypeVar, Protocol, runtime_checkable
+from typing import Callable, List, Optional, Any, Iterator
 
-T = TypeVar('T')
-
-@runtime_checkable
-class WebSocketClientProtocol(Protocol):
-    async def send(self, message: str) -> None: ...
-    async def close(self) -> None: ...
-    @property
-    def open(self) -> bool: ...
+import websockets
+from websockets.exceptions import ConnectionClosed
+from websockets.protocol import State
 
 # Setup module‐level logger with a default handler if none exists.
 logger = logging.getLogger(__name__)
@@ -44,9 +39,6 @@ class QuotesClient:
         max_message_size: int = 10 * 1024 * 1024,
         batch_size: int = 20
     ):
-        logger.debug("Initializing QuotesClient with params: base_url=%s, log_level=%s, max_message_size=%d, batch_size=%d", 
-                    base_url, log_level, max_message_size, batch_size)
-
         valid_levels = {"error": logging.ERROR, "info": logging.INFO, "debug": logging.DEBUG}
         if log_level not in valid_levels:
             raise ValueError(f"log_level must be one of {list(valid_levels.keys())}")
@@ -64,60 +56,66 @@ class QuotesClient:
             raise ValueError("Base URL must be provided as an argument or in .env (WZ__QUOTES_BASE_URL)")
 
         self.url = f"{self.base_url}?token={self.token}"
-        self.ws: Optional[WebSocketClientProtocol] = None
-        self.subscribed_instruments: Set[str] = set()
+        self.ws: Optional[websockets.WebSocketClientProtocol] = None
+        self.subscribed_instruments: set = set()
         self._running = False
-        self._background_task: Optional[asyncio.Task[None]] = None
+        self._background_task = None
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
 
         self._backoff_base = 1
         self._backoff_factor = 2
         self._backoff_max = 60
 
         # Callbacks are plain synchronous functions
-        self.on_tick: Optional[Callable[[Any, Dict[str, Any]], None]] = None
+        self.on_tick: Optional[Callable[[Any, dict], None]] = None
         self.on_connect: Optional[Callable[[Any], None]] = None
         self.on_close: Optional[Callable[[Any, Optional[int], Optional[str]], None]] = None
         self.on_error: Optional[Callable[[Any, Exception], None]] = None
 
-        logger.debug("QuotesClient initialized successfully")
+        logger.debug("Initialized QuotesClient with URL: %s", self.url)
 
     def _chunk_list(self, data: List[Any], chunk_size: int) -> Iterator[List[Any]]:
-        logger.debug("Chunking list of size %d with chunk_size %d", len(data), chunk_size)
-        return (data[i:i + chunk_size] for i in range(0, len(data), chunk_size))
+        for i in range(0, len(data), chunk_size):
+            yield data[i:i + chunk_size]
 
     async def _connect_with_backoff(self) -> None:
         backoff = self._backoff_base
-        logger.debug("Starting connection with initial backoff: %d", backoff)
 
         while self._running:
             try:
-                logger.debug("Attempting WebSocket connection to %s", self.url)
-                # Using string literal for import to avoid type checking issues
-                ws = await __import__('websockets').connect(self.url, max_size=self.max_message_size)
-                self.ws = ws
-                logger.debug("WebSocket connection established successfully")
-
-                if self.on_connect:
-                    logger.debug("Executing on_connect callback")
-                    try:
-                        self.on_connect(self)
-                    except Exception as e:
-                        logger.error("Error in on_connect callback: %s", e, exc_info=True)
-
-                if self.subscribed_instruments:
-                    logger.debug("Re-subscribing to %d instruments", len(self.subscribed_instruments))
-                    for batch in self._chunk_list(list(self.subscribed_instruments), self.batch_size):
-                        msg = {"action": self.ACTION_SUBSCRIBE, "instruments": batch}
-                        if self.ws:  # Check if ws is not None
+                logger.info("Connecting to %s ...", self.url)
+                async with websockets.connect(self.url, max_size=self.max_message_size) as websocket:
+                    self.ws = websocket
+                    logger.info("Connected to the quotes server.")
+
+                    # plain sync on_connect
+                    if self.on_connect:
+                        try:
+                            self.on_connect(self)
+                        except Exception as e:
+                            logger.error("Error in on_connect callback: %s", e, exc_info=True)
+
+                    # re-subscribe on reconnect
+                    if self.subscribed_instruments:
+                        for batch in self._chunk_list(list(self.subscribed_instruments), self.batch_size):
+                            msg = {"action": self.ACTION_SUBSCRIBE, "instruments": batch}
                             await self.ws.send(json.dumps(msg))
                             logger.info("Re-subscribed to %d instruments", len(batch))
                             await asyncio.sleep(0.1)
 
-                backoff = self._backoff_base
-                await self._handle_messages()
+                    backoff = self._backoff_base
+                    await self._handle_messages()
+
+            except ConnectionClosed as e:
+                logger.info("Disconnected: %s", e)
+                if self.on_close:
+                    try:
+                        self.on_close(self, getattr(e, 'code', None), str(e))
+                    except Exception as ex:
+                        logger.error("Error in on_close callback: %s", ex, exc_info=True)
 
             except Exception as e:
-                logger.debug("Connection error occurred: %s", str(e), exc_info=True)
+                logger.error("Connection error: %s", e, exc_info=True)
                 if self.on_error:
                     try:
                         self.on_error(self, e)
@@ -125,115 +123,117 @@ class QuotesClient:
                         logger.error("Error in on_error callback: %s", ex, exc_info=True)
 
             if not self._running:
-                logger.debug("Client stopped, breaking reconnection loop")
                 break
 
             sleep_time = min(backoff, self._backoff_max)
-            logger.debug("Calculated reconnection backoff: %s seconds", sleep_time)
+            logger.info("Reconnecting in %s seconds...", sleep_time)
             await asyncio.sleep(sleep_time)
             backoff = backoff * self._backoff_factor + random.uniform(0, 1)
 
     async def _handle_messages(self) -> None:
         try:
-            logger.debug("Starting message handling loop")
-            if self.ws is None:
-                logger.error("WebSocket connection is None")
-                return
-                
-            # Using string literal for import to avoid type checking issues
             async for message in self.ws:  # type: ignore
+                if self.log_level == "debug" and isinstance(message, str):
+                    size = len(message.encode("utf-8"))
+                    if size > 1024 * 1024:
+                        logger.debug("Large message: %d bytes", size)
+
                 if isinstance(message, str):
-                    msg_size = len(message.encode("utf-8"))
-                    logger.debug("Received message of size: %d bytes", msg_size)
-                    
                     for chunk in message.strip().split("\n"):
                         if not chunk:
                             continue
                         try:
                             tick = json.loads(chunk)
-                            logger.debug("Successfully parsed JSON message for instrument: %s", 
-                                       tick.get('instrument', 'unknown'))
                             if self.on_tick:
-                                logger.debug("Executing on_tick callback")
                                 self.on_tick(self, tick)
                         except json.JSONDecodeError as e:
-                            logger.debug("Failed to parse JSON message: %s. Content: %s", str(e), chunk[:100])
                             logger.error("JSON parse error: %s", e)
                 else:
-                    logger.debug("Received non-string message of type: %s", type(message).__name__)
-                    logger.warning("Non-string message: %s", type(message).__name__)
+                    logger.warning("Non-string message: %s", type(message))
+        except ConnectionClosed:
+            logger.info("Connection closed during message handling")
         except Exception as e:
-            logger.debug("Error in message handling: %s", str(e), exc_info=True)
+            logger.error("Error processing message: %s", e, exc_info=True)
             if self.on_error:
                 try:
                     self.on_error(self, e)
                 except Exception:
                     pass
 
+    # -- Async core methods (for internal use) --
+
     async def _subscribe_async(self, instruments: List[str]) -> None:
-        logger.debug("Processing async subscription request for %d instruments", len(instruments))
-        if self.ws and self.ws.open:
+        if self.ws and self.ws.state == State.OPEN:
             new = set(instruments) - self.subscribed_instruments
             if new:
-                logger.debug("Found %d new instruments to subscribe", len(new))
                 self.subscribed_instruments |= new
                 for batch in self._chunk_list(list(new), self.batch_size):
-                    logger.debug("Sending subscription request for batch of %d instruments", len(batch))
+                    logger.info("Subscribing to %d instruments", len(batch))
                     await self.ws.send(json.dumps({
                         "action": self.ACTION_SUBSCRIBE,
                         "instruments": batch
                     }))
                     await asyncio.sleep(0.1)
         else:
-            logger.debug("WebSocket not ready, queueing %d instruments for later subscription", len(instruments))
             self.subscribed_instruments |= set(instruments)
 
     async def _unsubscribe_async(self, instruments: List[str]) -> None:
-        logger.debug("Processing async unsubscription request for %d instruments", len(instruments))
-        if self.ws and self.ws.open:
+        if self.ws and self.ws.state == State.OPEN:
             to_remove = set(instruments) & self.subscribed_instruments
             if to_remove:
-                logger.debug("Found %d instruments to unsubscribe", len(to_remove))
+                self.subscribed_instruments -= to_remove
                 for batch in self._chunk_list(list(to_remove), self.batch_size):
-                    logger.debug("Sending unsubscription request for batch of %d instruments", len(batch))
+                    logger.info("Unsubscribing from %d instruments", len(batch))
                     await self.ws.send(json.dumps({
                         "action": self.ACTION_UNSUBSCRIBE,
                         "instruments": batch
                     }))
                     await asyncio.sleep(0.1)
-                logger.debug("Removed %d instruments from subscription set", len(to_remove))
-                self.subscribed_instruments -= to_remove
         else:
-            logger.debug("WebSocket not ready, removing %d instruments from queue", len(instruments))
             self.subscribed_instruments -= set(instruments)
 
+    # -- Public wrappers for plain callback users --
+
     def subscribe(self, instruments: List[str]) -> None:
-        logger.debug("Scheduling subscription for %d instruments", len(instruments))
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        loop.create_task(self._subscribe_async(instruments))
+        """
+        Schedule subscribe onto the client’s event loop.
+        """
+        if self._loop:
+            asyncio.run_coroutine_threadsafe(
+                self._subscribe_async(instruments),
+                self._loop
+            )
+        else:
+            self.subscribed_instruments |= set(instruments)
 
     def unsubscribe(self, instruments: List[str]) -> None:
-        logger.debug("Scheduling unsubscription for %d instruments", len(instruments))
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        loop.create_task(self._unsubscribe_async(instruments))
+        """
+        Schedule unsubscribe onto the client’s event loop.
+        """
+        if self._loop:
+            asyncio.run_coroutine_threadsafe(
+                self._unsubscribe_async(instruments),
+                self._loop
+            )
+        else:
+            self.subscribed_instruments -= set(instruments)
+
+    def unsubscribe_all(self) -> None:
+        """
+        Unsubscribe from all currently subscribed instruments.
+        """
+        if self.subscribed_instruments:
+            self.unsubscribe(list(self.subscribed_instruments))
 
     async def close(self) -> None:
-        logger.debug("Initiating WebSocket connection closure")
+        """
+        Close the WebSocket connection.
+        """
         self._running = False
         if self.ws:
-            logger.debug("Closing active WebSocket connection")
             await self.ws.close()
             logger.info("WebSocket closed.")
         if self._background_task and not self._background_task.done():
-            logger.debug("Cancelling background connection task")
             self._background_task.cancel()
             try:
                 await self._background_task
@@ -241,13 +241,16 @@ class QuotesClient:
                 pass
 
     def connect(self) -> None:
-        logger.debug("Starting blocking connect operation")
+        """
+        Blocking connect (runs the internal asyncio loop until stop()).
+        """
         self._running = True
         try:
             loop = asyncio.get_event_loop()
         except RuntimeError:
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
+        self._loop = loop
 
         try:
             loop.run_until_complete(self._connect_with_backoff())
@@ -262,15 +265,20 @@ class QuotesClient:
                     pass
 
     def connect_async(self) -> None:
-        logger.debug("Starting non-blocking async connect operation")
+        """
+        Non-blocking connect: starts the background task.
+        """
         if self._running:
             logger.warning("Client already running.")
             return
         self._running = True
         loop = asyncio.get_event_loop()
+        self._loop = loop
         self._background_task = loop.create_task(self._connect_with_backoff())
 
     def stop(self) -> None:
-        logger.debug("Stop signal received")
+        """
+        Signal the client to stop and close.
+        """
         self._running = False
         logger.info("Client stopping; will close soon.")

{wiz_trader-0.23.0.dist-info → wiz_trader-0.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.23.0
+Version: 0.24.0
 Summary: A Python SDK for connecting to the Wizzer.
 Home-page: https://bitbucket.org/wizzer-tech/quotes_sdk.git
 Author: Pawan Wagh

wiz_trader-0.24.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+wiz_trader/__init__.py,sha256=hL8zImLBBtwxnrKrTpTqcsIzg5cxFMWDOfTkfKNwo9o,182
+wiz_trader/apis/__init__.py,sha256=ItWKMOl4omiW0g2f-M7WRW3v-dss_ULd9vYnFyIIT9o,132
+wiz_trader/apis/client.py,sha256=GY1aAaV4ia1tnFnB2qaNqnv-qeUvkVlvw9xOKN54qIs,59786
+wiz_trader/quotes/__init__.py,sha256=RF9g9CNP6bVWlmCh_ad8krm3-EWOIuVfLp0-H9fAeEM,108
+wiz_trader/quotes/client.py,sha256=oPDOKqc9EChID_V0_O7ziCdcDnyM_jC7uuKfkc1GwmI,10959
+wiz_trader-0.24.0.dist-info/METADATA,sha256=38v7XP4SiKWiNDaIAex2cHkv7afK8ExKzs5pv-MKFzM,87046
+wiz_trader-0.24.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wiz_trader-0.24.0.dist-info/top_level.txt,sha256=lnYS_g8LlA6ryKYnvY8xIQ6K2K-xzOsd-99AWgnW6VY,11
+wiz_trader-0.24.0.dist-info/RECORD,,

wiz_trader-0.23.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-wiz_trader/__init__.py,sha256=6c10AeBkvODzgW6IRSOimyIKsojSQTsjDk05-tZwcrs,182
-wiz_trader/apis/__init__.py,sha256=ItWKMOl4omiW0g2f-M7WRW3v-dss_ULd9vYnFyIIT9o,132
-wiz_trader/apis/client.py,sha256=GY1aAaV4ia1tnFnB2qaNqnv-qeUvkVlvw9xOKN54qIs,59786
-wiz_trader/quotes/__init__.py,sha256=RF9g9CNP6bVWlmCh_ad8krm3-EWOIuVfLp0-H9fAeEM,108
-wiz_trader/quotes/client.py,sha256=UTkBGwrrlNO6i5r8oH63B9vXTvkvb-_bFlqHGiHufik,12289
-wiz_trader-0.23.0.dist-info/METADATA,sha256=O_3IvT5NG0r-YMthKIZZSq_refcgZRdZfT1LykSFwl0,87046
-wiz_trader-0.23.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wiz_trader-0.23.0.dist-info/top_level.txt,sha256=lnYS_g8LlA6ryKYnvY8xIQ6K2K-xzOsd-99AWgnW6VY,11
-wiz_trader-0.23.0.dist-info/RECORD,,