wiz-trader 0.22.0__tar.gz → 0.23.0__tar.gz

{wiz_trader-0.22.0/src/wiz_trader.egg-info → wiz_trader-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.22.0
+Version: 0.23.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.22.0 → wiz_trader-0.23.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wiz_trader"
-version = "0.22.0"
+version = "0.23.0"
 description = "A Python SDK for connecting to the Wizzer."
 readme = "README.md"
 authors = [

{wiz_trader-0.22.0 → wiz_trader-0.23.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
   name='wiz_trader',
-  version='0.22.0',
+  version='0.23.0',
   description='A Python SDK for connecting to the Wizzer.',
   long_description=open('README.md').read() if open('README.md') else "",
   long_description_content_type='text/markdown',

{wiz_trader-0.22.0 → wiz_trader-0.23.0}/src/wiz_trader/__init__.py

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

{wiz_trader-0.22.0 → wiz_trader-0.23.0}/src/wiz_trader/quotes/client.py

@@ -3,11 +3,16 @@ import json
 import os
 import logging
 import random
-from typing import Callable, List, Optional, Any, Iterator
+from typing import Callable, List, Optional, Any, Iterator, Dict, Set, TypeVar, Protocol, runtime_checkable
 
-import websockets
-from websockets.exceptions import ConnectionClosed
-from websockets.protocol import State
+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: ...
 
 # Setup module‐level logger with a default handler if none exists.
 logger = logging.getLogger(__name__)
@@ -39,6 +44,9 @@ 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())}")
@@ -56,65 +64,60 @@ 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[websockets.WebSocketClientProtocol] = None
-        self.subscribed_instruments: set = set()
+        self.ws: Optional[WebSocketClientProtocol] = None
+        self.subscribed_instruments: Set[str] = set()
         self._running = False
-        self._background_task = None
+        self._background_task: Optional[asyncio.Task[None]] = 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], None]] = None
+        self.on_tick: Optional[Callable[[Any, Dict[str, Any]], 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("Initialized QuotesClient with URL: %s", self.url)
+        logger.debug("QuotesClient initialized successfully")
 
     def _chunk_list(self, data: List[Any], chunk_size: int) -> Iterator[List[Any]]:
-        for i in range(0, len(data), chunk_size):
-            yield data[i:i + chunk_size]
+        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))
 
     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.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}
+                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
                             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()
-
-            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)
+                backoff = self._backoff_base
+                await self._handle_messages()
 
             except Exception as e:
-                logger.error("Connection error: %s", e, exc_info=True)
+                logger.debug("Connection error occurred: %s", str(e), exc_info=True)
                 if self.on_error:
                     try:
                         self.on_error(self, e)
@@ -122,120 +125,115 @@ 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.info("Reconnecting in %s seconds...", sleep_time)
+            logger.debug("Calculated reconnection backoff: %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.warning("Non-string message: %s", type(message))
-        except ConnectionClosed:
-            logger.info("Connection closed during message handling")
+                    logger.debug("Received non-string message of type: %s", type(message).__name__)
+                    logger.warning("Non-string message: %s", type(message).__name__)
         except Exception as e:
-            logger.error("Error processing message: %s", e, exc_info=True)
+            logger.debug("Error in message handling: %s", str(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:
-        """
-        Internal async subscription. Use `subscribe()` wrapper to schedule this.
-        """
-        if self.ws and self.ws.state == State.OPEN:
+        logger.debug("Processing async subscription request for %d instruments", len(instruments))
+        if self.ws and self.ws.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.info("Subscribing to %d instruments", len(batch))
+                    logger.debug("Sending subscription request for batch of %d instruments", len(batch))
                     await self.ws.send(json.dumps({
                         "action": self.ACTION_SUBSCRIBE,
                         "instruments": batch
                     }))
                     await asyncio.sleep(0.1)
         else:
-            # queue it for next connect
+            logger.debug("WebSocket not ready, queueing %d instruments for later subscription", len(instruments))
             self.subscribed_instruments |= set(instruments)
 
-    # -- Public wrappers for plain callback users --
-
-    def subscribe(self, instruments: List[str]) -> None:
-        """
-        Schedule an async subscribe so users can call this without 'await'.
-        """
-        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))
-
     async def _unsubscribe_async(self, instruments: List[str]) -> None:
-        """
-        Internal async unsubscription. Use `unsubscribe()` wrapper to schedule this.
-        """
-        # Only send unsubs if the socket is open
-        if self.ws and self.ws.state == State.OPEN:
+        logger.debug("Processing async unsubscription request for %d instruments", len(instruments))
+        if self.ws and self.ws.open:
             to_remove = set(instruments) & self.subscribed_instruments
             if to_remove:
+                logger.debug("Found %d instruments to unsubscribe", len(to_remove))
                 for batch in self._chunk_list(list(to_remove), self.batch_size):
-                    logger.info("Unsubscribing from %d instruments", len(batch))
+                    logger.debug("Sending unsubscription request for batch of %d instruments", len(batch))
                     await self.ws.send(json.dumps({
                         "action": self.ACTION_UNSUBSCRIBE,
                         "instruments": batch
                     }))
                     await asyncio.sleep(0.1)
-                # remove them from our local set
+                logger.debug("Removed %d instruments from subscription set", len(to_remove))
                 self.subscribed_instruments -= to_remove
         else:
-            # if we're not connected yet, just remove from the queue
+            logger.debug("WebSocket not ready, removing %d instruments from queue", len(instruments))
             self.subscribed_instruments -= set(instruments)
 
+    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))
+
     def unsubscribe(self, instruments: List[str]) -> None:
-        """
-        Schedule an async unsubscribe so users can call this without 'await'.
-        """
+        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))
-    
-    # You could add a similar unsubscribe wrapper if needed
 
     async def close(self) -> None:
-        """
-        Close the WebSocket connection.
-        """
+        logger.debug("Initiating WebSocket connection closure")
         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
@@ -243,9 +241,7 @@ class QuotesClient:
                 pass
 
     def connect(self) -> None:
-        """
-        Blocking connect (runs the internal asyncio loop until stop()).
-        """
+        logger.debug("Starting blocking connect operation")
         self._running = True
         try:
             loop = asyncio.get_event_loop()
@@ -266,9 +262,7 @@ class QuotesClient:
                     pass
 
     def connect_async(self) -> None:
-        """
-        Non-blocking connect: starts the background task.
-        """
+        logger.debug("Starting non-blocking async connect operation")
         if self._running:
             logger.warning("Client already running.")
             return
@@ -277,8 +271,6 @@ class QuotesClient:
         self._background_task = loop.create_task(self._connect_with_backoff())
 
     def stop(self) -> None:
-        """
-        Signal the client to stop and close.
-        """
+        logger.debug("Stop signal received")
         self._running = False
         logger.info("Client stopping; will close soon.")

{wiz_trader-0.22.0 → wiz_trader-0.23.0/src/wiz_trader.egg-info}/PKG-INFO

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