wiz-trader 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

wiz_trader/__init__.py

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

wiz_trader/quotes/client.py

@@ -3,346 +3,250 @@ import json
 import os
 import logging
 import random
-from typing import Callable, List, Optional, Any, Dict, Iterator
+from typing import Callable, List, Optional, Any, Iterator
 
 import websockets
 from websockets.exceptions import ConnectionClosed
 from websockets.protocol import State
 
-# Setup module-level logger with a default handler if none exists.
+# Setup module‐level logger with a default handler if none exists.
 logger = logging.getLogger(__name__)
 if not logger.handlers:
-  handler = logging.StreamHandler()
-  formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-  handler.setFormatter(formatter)
-  logger.addHandler(handler)
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
 
 
 class QuotesClient:
-  """
-  A Python SDK for connecting to the Quotes Server via WebSocket.
-
-  Attributes:
-    base_url (str): WebSocket URL of the quotes server.
-    token (str): JWT token for authentication.
-    log_level (str): Logging level. Options: "error", "info", "debug".
-  """
-
-  # Constants for actions
-  ACTION_SUBSCRIBE = "subscribe"
-  ACTION_UNSUBSCRIBE = "unsubscribe"
-
-  def __init__(
-    self, 
-    base_url: Optional[str] = None, 
-    token: Optional[str] = None,
-    log_level: str = "error",  # default only errors
-    max_message_size: int = 10 * 1024 * 1024,  # 10MB default max size
-    batch_size: int = 20  # Max number of instruments to subscribe to at once
-  ):
-    # Configure logger based on log_level.
-    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())}")
-    logger.setLevel(valid_levels[log_level])
-    
-    self.log_level = log_level
-    self.max_message_size = max_message_size
-    self.batch_size = batch_size
-    # System env vars take precedence over .env
-    self.base_url = base_url or os.environ.get("WZ__QUOTES_BASE_URL")
-    self.token = token or os.environ.get("WZ__TOKEN")
-    if not self.token:
-      raise ValueError("JWT token must be provided as an argument or in .env (WZ__TOKEN)")
-    if not self.base_url:
-      raise ValueError("Base URL must be provided as an argument or in .env (WZ__QUOTES_BASE_URL)")
-
-    # Construct the WebSocket URL.
-    self.url = f"{self.base_url}?token={self.token}"
-    self.ws: Optional[websockets.WebSocketClientProtocol] = None
-    self.subscribed_instruments: set = set()
-    self._running = False
-    self._background_task = None
-
-    # Backoff configuration for reconnection (in seconds)
-    self._backoff_base = 1
-    self._backoff_factor = 2
-    self._backoff_max = 60
-
-    # Callbacks
-    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("Initialized QuotesClient with URL: %s", self.url)
-
-  def _chunk_list(self, data: List[Any], chunk_size: int) -> Iterator[List[Any]]:
     """
-    Split a list into smaller chunks.
-    
-    Args:
-        data (List[Any]): The list to split.
-        chunk_size (int): Maximum size of each chunk.
-        
-    Returns:
-        Iterator[List[Any]]: Iterator of list chunks.
-    """
-    for i in range(0, len(data), chunk_size):
-        yield data[i:i + chunk_size]
-
-  async def _connect_with_backoff(self) -> None:
-    """
-    Continuously connect to the quotes server with exponential backoff.
-    """
-    backoff = self._backoff_base
-
-    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.")
-          
-          # Call the on_connect callback if provided
-          if self.on_connect:
+    A Python SDK for connecting to the Quotes Server via WebSocket.
+
+    Attributes:
+      base_url (str): WebSocket URL of the quotes server.
+      token (str): JWT token for authentication.
+      log_level (str): Logging level. Options: "error", "info", "debug".
+    """
+
+    ACTION_SUBSCRIBE = "subscribe"
+    ACTION_UNSUBSCRIBE = "unsubscribe"
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        token: Optional[str] = None,
+        log_level: str = "error",
+        max_message_size: int = 10 * 1024 * 1024,
+        batch_size: int = 20
+    ):
+        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())}")
+        logger.setLevel(valid_levels[log_level])
+
+        self.log_level = log_level
+        self.max_message_size = max_message_size
+        self.batch_size = batch_size
+
+        self.base_url = base_url or os.environ.get("WZ__QUOTES_BASE_URL")
+        self.token = token or os.environ.get("WZ__TOKEN")
+        if not self.token:
+            raise ValueError("JWT token must be provided as an argument or in .env (WZ__TOKEN)")
+        if not self.base_url:
+            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._running = False
+        self._background_task = 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_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)
+
+    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]
+
+    async def _connect_with_backoff(self) -> None:
+        backoff = self._backoff_base
+
+        while self._running:
             try:
-              self.on_connect(self)
+                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()
+
+            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.error("Error in on_connect callback: %s", e, exc_info=True)
-          
-          # On reconnection, re-subscribe if needed.
-          if self.subscribed_instruments:
-            # Split into batches to avoid message size issues
-            instruments_list = list(self.subscribed_instruments)
-            for batch in self._chunk_list(instruments_list, self.batch_size):
-              subscribe_msg = {
-                "action": self.ACTION_SUBSCRIBE,
-                "instruments": batch
-              }
-              await self.ws.send(json.dumps(subscribe_msg))
-              logger.info("Re-subscribed to batch of %d instruments", len(batch))
-              # Small delay between batches to avoid overwhelming the server
-              await asyncio.sleep(0.1)
-
-          # Reset backoff after a successful connection.
-          backoff = self._backoff_base
-
-          await self._handle_messages()
-      except ConnectionClosed as e:
-        logger.info("Disconnected from the quotes server: %s", e)
-        # Call the on_close callback if provided
-        if self.on_close:
-          try:
-            self.on_close(self, getattr(e, 'code', None), str(e))
-          except Exception as e:
-            logger.error("Error in on_close callback: %s", e, exc_info=True)
-      except Exception as e:
-        logger.error("Connection error: %s", e, exc_info=True)
-        # Call the on_error callback if provided
-        if self.on_error:
-          try:
-            self.on_error(self, e)
-          except Exception as e:
-            logger.error("Error in on_error callback: %s", e, exc_info=True)
-
-      # Don't reconnect if we're no longer running
-      if not self._running:
-        break
-        
-      # Exponential backoff before reconnecting.
-      sleep_time = min(backoff, self._backoff_max)
-      logger.info("Reconnecting in %s seconds...", sleep_time)
-      await asyncio.sleep(sleep_time)
-      backoff *= self._backoff_factor
-      # Add a bit of randomness to avoid thundering herd issues.
-      backoff += random.uniform(0, 1)
-
-  async def _handle_messages(self) -> None:
-    """
-    Handle incoming messages and dispatch them via the on_tick callback.
-    Handles newline-delimited JSON objects in a single message.
-    """
-    try:
-      async for message in self.ws:  # type: ignore
-        # Log message size for debugging large message issues
-        if self.log_level == "debug" and isinstance(message, str):
-          message_size = len(message.encode("utf-8"))
-          if message_size > 1024 * 1024:  # Over 1MB
-            logger.debug("Received large message: %d bytes", message_size)
-            # Log the beginning of the message for debugging
-            logger.debug("Message starts with: %s", message[:100])
-        
-        if isinstance(message, str):
-          # Special handling for newline-delimited JSON
-          if '\n' in message:
-            # Split by newlines and process each JSON object separately
-            for json_str in message.strip().split('\n'):
-              if not json_str:
-                continue
-                
-              try:
-                tick = json.loads(json_str)
-                if self.on_tick:
-                  self.on_tick(self, tick)
-              except json.JSONDecodeError as e:
-                logger.error("Failed to parse JSON object: %s", str(e))
-                logger.error("Invalid JSON: %s...", json_str[:100])
-          else:
-            # Single JSON object
-            try:
-              tick = json.loads(message)
-              if self.on_tick:
-                self.on_tick(self, tick)
-            except json.JSONDecodeError as e:
-              logger.error("Failed to parse JSON: %s", str(e))
-              logger.error("Invalid JSON message: %s...", message[:100])
-        else:
-          logger.warning("Received non-string message: %s", type(message))
-    except ConnectionClosed as e:
-      logger.info("Connection closed during message handling: %s", e)
-      # Let the _connect_with_backoff method handle reconnection
-    except Exception as e:
-      logger.error("Error processing message: %s", str(e), exc_info=True)
-      # Call the on_error callback if provided
-      if self.on_error:
+                logger.error("Connection error: %s", e, exc_info=True)
+                if self.on_error:
+                    try:
+                        self.on_error(self, e)
+                    except Exception as ex:
+                        logger.error("Error in on_error callback: %s", ex, exc_info=True)
+
+            if not self._running:
+                break
+
+            sleep_time = min(backoff, self._backoff_max)
+            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:
-          self.on_error(self, e)
+            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):
+                    for chunk in message.strip().split("\n"):
+                        if not chunk:
+                            continue
+                        try:
+                            tick = json.loads(chunk)
+                            if self.on_tick:
+                                self.on_tick(self, tick)
+                        except json.JSONDecodeError as e:
+                            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")
         except Exception as e:
-          logger.error("Error in on_error callback: %s", e, exc_info=True)
-
-  async def subscribe(self, instruments: List[str]) -> None:
-    """
-    Subscribe to a list of instruments.
+            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:
+        """
+        Internal async subscription. Use `subscribe()` wrapper to schedule this.
+        """
+        if self.ws and self.ws.state == State.OPEN:
+            new = set(instruments) - self.subscribed_instruments
+            if new:
+                self.subscribed_instruments |= new
+                for batch in self._chunk_list(list(new), self.batch_size):
+                    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:
+            # queue it for next connect
+            self.subscribed_instruments |= set(instruments)
 
-    Args:
-      instruments (List[str]): List of instrument identifiers.
-    """
-    if self.ws and self.ws.state == State.OPEN:
-      new_instruments = set(instruments) - self.subscribed_instruments
-      if new_instruments:
-        self.subscribed_instruments.update(new_instruments)
-        
-        # Split into batches to avoid message size issues
-        new_instruments_list = list(new_instruments)
-        for batch in self._chunk_list(new_instruments_list, self.batch_size):
-          logger.info("Subscribing to batch of %d instruments", len(batch))
-          message = {"action": self.ACTION_SUBSCRIBE, "instruments": batch}
-          await self.ws.send(json.dumps(message))
-          # Small delay between batches to avoid overwhelming the server
-          await asyncio.sleep(0.1)
-        
-        logger.info("Completed subscription for %d new instruments", len(new_instruments))
-      else:
-        logger.info("Instruments already subscribed: %s", instruments)
-    else:
-      logger.info("Cannot subscribe: WebSocket is not connected.")
-      # Still update the subscription list so we can subscribe when connected
-      self.subscribed_instruments.update(set(instruments))
-
-  async def unsubscribe(self, instruments: List[str]) -> None:
-    """
-    Unsubscribe from a list of instruments.
+    # -- Public wrappers for plain callback users --
 
-    Args:
-      instruments (List[str]): List of instrument identifiers.
-    """
-    if self.ws and self.ws.state == State.OPEN:
-      unsub_set = set(instruments)
-      to_unsubscribe = unsub_set & self.subscribed_instruments
-      
-      if to_unsubscribe:
-        self.subscribed_instruments.difference_update(to_unsubscribe)
-        
-        # Split into batches to avoid message size issues
-        unsub_list = list(to_unsubscribe)
-        for batch in self._chunk_list(unsub_list, self.batch_size):
-          logger.info("Unsubscribing from batch of %d instruments", len(batch))
-          message = {"action": self.ACTION_UNSUBSCRIBE, "instruments": batch}
-          await self.ws.send(json.dumps(message))
-          # Small delay between batches to avoid overwhelming the server
-          await asyncio.sleep(0.1)
-          
-        logger.info("Completed unsubscription for %d instruments", len(to_unsubscribe))
-      else:
-        logger.info("No matching instruments found in current subscription.")
-    else:
-      logger.info("Cannot unsubscribe: WebSocket is not connected.")
-      # Still update the subscription list
-      self.subscribed_instruments.difference_update(set(instruments))
-
-  async def close(self) -> None:
-    """
-    Close the WebSocket connection.
-    """
-    self._running = False
-    if self.ws:
-      await self.ws.close()
-      logger.info("WebSocket connection closed.")
-    
-    # Cancel the background task if it exists
-    if self._background_task and not self._background_task.done():
-      self._background_task.cancel()
-      try:
-        await self._background_task
-      except asyncio.CancelledError:
-        pass
-
-  def connect(self) -> None:
-    """
-    Connect to the websocket server in a blocking manner.
-    This method handles the event loop and will not return until stop() is called.
-    
-    Similar to KiteTicker's connect() method, this creates and runs the event loop.
-    """
-    self._running = True
-    
-    # If there's already an event loop, use it
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        # No event loop exists, create a new one
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    
-    try:
-        # Run until completion (i.e., until stop() is called)
-        loop.run_until_complete(self._connect_with_backoff())
-    finally:
-        if not loop.is_closed():
-            # Clean up pending tasks
-            pending = asyncio.all_tasks(loop)
-            for task in pending:
-                task.cancel()
-            
-            # Run until all tasks are properly canceled
+    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))
+
+    # You could add a similar unsubscribe wrapper if needed
+
+    async def close(self) -> None:
+        """
+        Close the WebSocket connection.
+        """
+        self._running = False
+        if self.ws:
+            await self.ws.close()
+            logger.info("WebSocket closed.")
+        if self._background_task and not self._background_task.done():
+            self._background_task.cancel()
             try:
-                loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
-            except Exception:
+                await self._background_task
+            except asyncio.CancelledError:
                 pass
 
-  def connect_async(self) -> None:
-    """
-    Connect to the websocket server in a non-blocking manner.
-    This method starts the connection in a background task.
-    """
-    if self._running:
-      logger.warning("Client is already running.")
-      return
-    
-    self._running = True
-    try:
+    def connect(self) -> None:
+        """
+        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)
+
+        try:
+            loop.run_until_complete(self._connect_with_backoff())
+        finally:
+            if not loop.is_closed():
+                tasks = asyncio.all_tasks(loop)
+                for t in tasks:
+                    t.cancel()
+                try:
+                    loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+                except Exception:
+                    pass
+
+    def connect_async(self) -> None:
+        """
+        Non-blocking connect: starts the background task.
+        """
+        if self._running:
+            logger.warning("Client already running.")
+            return
+        self._running = True
         loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    
-    self._background_task = asyncio.create_task(self._connect_with_backoff())
-    
-  def stop(self) -> None:
-    """
-    Stop the websocket connection.
-    This is a non-blocking method that just flags the client to stop.
-    """
-    self._running = False
-    logger.info("Client stopping. Connection will close soon.")
+        self._background_task = loop.create_task(self._connect_with_backoff())
+
+    def stop(self) -> None:
+        """
+        Signal the client to stop and close.
+        """
+        self._running = False
+        logger.info("Client stopping; will close soon.")

{wiz_trader-0.10.0.dist-info → wiz_trader-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.10.0
+Version: 0.11.0
 Summary: A Python SDK for connecting to the Wizzer.
 Home-page: https://bitbucket.org/wizzer-tech/quotes_sdk.git
 Author: Pawan Wagh
@@ -132,7 +132,7 @@ quotes_client = QuotesClient(log_level="debug")  # Only override log level
 
 ## Quotes Client
 
-The `QuotesClient` enables you to connect to Wizzer's WebSocket server for real-time market data.
+The `QuotesClient` enables you to connect to Wizzer's WebSocket server for real‑time market data using **plain synchronous** callbacks—no `async def` required.
 
 ### Quotes Client Initialization
 
@@ -145,214 +145,155 @@ from wiz_trader import QuotesClient
 client = QuotesClient(
     base_url="wss://websocket-url/quotes",
     token="your-jwt-token",
-    log_level="info",  # Options: "error", "info", "debug"
-    max_message_size=10 * 1024 * 1024,  # Optional: Set max message size (default 10MB)
-    batch_size=20  # Optional: Max instruments per subscription batch (default 20)
+    log_level="info",         # Options: "error", "info", "debug"
+    max_message_size=10 * 1024 * 1024,  # Optional: default 10MB
+    batch_size=20             # Optional: default 20 instruments per batch
 )
 
 # Method 2: Using environment variables
-# (Requires WZ__QUOTES_BASE_URL and WZ__TOKEN to be set)
+# (Requires WZ__QUOTES_BASE_URL and WZ__TOKEN set)
 client = QuotesClient(log_level="info")
 
-# Method 3: Mixed approach (some params direct, some from env vars)
+# Method 3: Mixed approach
 client = QuotesClient(
-    base_url="wss://custom-websocket-url/quotes",
-    log_level="debug"
-    # token will be taken from WZ__TOKEN environment variable
+    base_url="wss://custom-url/quotes",
+    log_level="debug"         # token from WZ__TOKEN env var
 )
 ```
 
 ### Connection Methods
 
-The `QuotesClient` offers two ways to connect:
-
 #### Blocking Connection
 
-This approach is similar to Zerodha's KiteTicker and is recommended for simple scripts:
+Blocks your main thread, similar to Zerodha’s KiteTicker:
 
 ```python
-# This will block and run until stopped
 client.connect()
 ```
 
-#### Non-Blocking Connection
+#### Non‑Blocking Connection
 
-Use this for more complex applications where you need to perform other tasks:
+Run alongside your own `asyncio` code:
 
 ```python
-# Start the connection in the background
 client.connect_async()
-
-# Later, when you want to stop:
+# … do other work …
 client.stop()
 ```
 
 ### Callbacks
 
-Set up callbacks to handle different events:
+All callbacks are **plain `def`** functions.  Inside them you can call `subscribe(...)`, which under the hood schedules the actual async work—so you never `await` in your callbacks.
 
 ```python
 def on_tick(ws, tick):
-    """Called when a tick is received"""
-    print(f"Received tick: {tick}")
+    print("Tick:", tick)
 
 def on_connect(ws):
-    """Called when the connection is established"""
-    print("Connected to the quotes server")
-    # Subscribe to instruments
-    ws.subscribe(["NSE:SBIN:3045"])
+    print("Connected!")
+    # fire‑and‑forget subscribe—no await needed
+    ws.subscribe([
+        "NSE:SBIN:3045",
+        "NSE:RELIANCE:2885"
+    ])
 
 def on_close(ws, code, reason):
-    """Called when the connection is closed"""
-    print(f"Connection closed with code {code}: {reason}")
-    # Optional: Stop the client (if you want to exit)
-    # ws.stop()
+    print(f"Connection closed [{code}]: {reason}")
+    ws.stop()   # to prevent auto‑reconnect
 
 def on_error(ws, error):
-    """Called when an error occurs"""
-    print(f"Error: {error}")
+    print("Error:", error)
 
-# Set the callbacks
-client.on_tick = on_tick
+client.on_tick    = on_tick
 client.on_connect = on_connect
-client.on_close = on_close
-client.on_error = on_error
+client.on_close   = on_close
+client.on_error   = on_error
 ```
 
 ### Subscribing to Instruments
 
-Subscribe to receive market data for specific instruments:
+Call `ws.subscribe([...])` directly; the SDK will batch large lists and send them over the socket:
 
 ```python
-# Inside an on_connect callback:
 def on_connect(ws):
-    # Subscribe to a single instrument
-    ws.subscribe(["NSE:SBIN:3045"])
-    
-    # Or subscribe to multiple instruments at once
+    # subscribe without await
     ws.subscribe([
         "NSE:SBIN:3045",
         "NSE:ICICIBANK:4963",
-        "NSE:RELIANCE:2885"
+        "NSE:RELIANCE:2885",
     ])
 ```
 
-For large lists of instruments, the client will automatically batch them to avoid message size issues.
-
 ### Unsubscribing from Instruments
 
-To stop receiving data for specific instruments:
+Similarly, plain call to `unsubscribe`:
 
 ```python
-# Unsubscribe from specific instruments
 ws.unsubscribe(["NSE:SBIN:3045", "NSE:ICICIBANK:4963"])
 ```
 
-### Handling WebSocket Connection
-
-The WebSocket connection automatically attempts to reconnect with exponential backoff if disconnected. You don't need to handle this manually.
-
-To explicitly close the connection:
-
-```python
-# In a blocking context:
-client.stop()
-
-# In an async context:
-await client.close()
-```
-
-### Quotes Client Examples
+### Complete Examples
 
-#### Complete Blocking Example
+#### Blocking Example
 
 ```python
 import logging
 from wiz_trader import QuotesClient
 
-# Configure logging
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.INFO)
 
-# Initialize the client
 client = QuotesClient(
     base_url="wss://websocket-url/quotes",
     token="your-jwt-token"
 )
 
 def on_tick(ws, tick):
-    """Process incoming market data"""
-    logging.debug("Received tick: %s", tick)
+    logging.debug("Tick: %s", tick)
 
 def on_connect(ws):
-    """Handle successful connection"""
-    logging.info("Connected to quotes server")
-    # Subscribe to instruments
-    ws.subscribe(["NSE:SBIN:3045", "NSE:RELIANCE:2885"])
+    logging.info("Connected.")
+    ws.subscribe(["NSE:SBIN:3045", "NSE:RELIANCE:2885"])  # no await
 
 def on_close(ws, code, reason):
-    """Handle connection closure"""
-    logging.info("Connection closed: %s", reason)
+    logging.warning("Closed: %s", reason)
+    ws.stop()
 
 def on_error(ws, error):
-    """Handle errors"""
-    logging.error("Error occurred: %s", error)
+    logging.error("Error: %s", error)
 
-# Set callbacks
-client.on_tick = on_tick
+client.on_tick    = on_tick
 client.on_connect = on_connect
-client.on_close = on_close
-client.on_error = on_error
+client.on_close   = on_close
+client.on_error   = on_error
 
-# Connect and run (blocking call)
 try:
     client.connect()
 except KeyboardInterrupt:
-    print("Interrupted by user, shutting down...")
     client.stop()
 ```
 
-#### Non-Blocking Example with Other Operations
+#### Non‑Blocking Example
 
 ```python
 import asyncio
 import logging
-from wiz_trader import QuotesClient, WizzerClient
+from wiz_trader import QuotesClient
 
 async def main():
-    # Configure logging
     logging.basicConfig(level=logging.INFO)
-    
-    # Initialize the quotes client
-    quotes_client = QuotesClient(
+    client = QuotesClient(
         base_url="wss://websocket-url/quotes",
         token="your-jwt-token"
     )
-    
-    # Initialize the REST API client
-    wizzer_client = WizzerClient(
-        base_url="https://api-url.in",
-        token="your-jwt-token"
-    )
-    
-    # Set up quotes callbacks
-    quotes_client.on_tick = lambda ws, tick: logging.info(f"Tick: {tick}")
-    quotes_client.on_connect = lambda ws: ws.subscribe(["NSE:SBIN:3045"])
-    
-    # Connect in non-blocking mode
-    quotes_client.connect_async()
-    
-    # Perform other operations
-    indices = await asyncio.to_thread(wizzer_client.get_indices, exchange="NSE")
-    logging.info(f"Available indices: {[idx['name'] for idx in indices[:5]]}")
-    
-    # Wait for some time
+    client.on_tick    = lambda ws, tick: logging.info(tick)
+    client.on_connect = lambda ws: ws.subscribe(["NSE:SBIN:3045"])
+    client.connect_async()
+
+    # Your other async work here...
     await asyncio.sleep(60)
-    
-    # Stop the quotes client
-    quotes_client.stop()
+    client.stop()
 
-if __name__ == "__main__":
-    asyncio.run(main())
+asyncio.run(main())
 ```
 
 ## Wizzer Client

wiz_trader-0.11.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+wiz_trader/__init__.py,sha256=C0FSsZWVvQ5bLn9WzjVb3QD4erLfxjy5V0bCAjxBECE,182
+wiz_trader/apis/__init__.py,sha256=ItWKMOl4omiW0g2f-M7WRW3v-dss_ULd9vYnFyIIT9o,132
+wiz_trader/apis/client.py,sha256=4Vu9z0cLjJ62LTNT13UwicU0Ez3jnwQOcirWtJAF4Hw,25578
+wiz_trader/quotes/__init__.py,sha256=RF9g9CNP6bVWlmCh_ad8krm3-EWOIuVfLp0-H9fAeEM,108
+wiz_trader/quotes/client.py,sha256=LJeMcQPjJIRxrTIGalWsLYh_XfinDXBP5-4cNS7qCxc,9709
+wiz_trader-0.11.0.dist-info/METADATA,sha256=IpTpq7bUvtWlCM1f-BVOx9K2MTM_HCsLXd_T5aefXKU,53081
+wiz_trader-0.11.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+wiz_trader-0.11.0.dist-info/top_level.txt,sha256=lnYS_g8LlA6ryKYnvY8xIQ6K2K-xzOsd-99AWgnW6VY,11
+wiz_trader-0.11.0.dist-info/RECORD,,

wiz_trader-0.10.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-wiz_trader/__init__.py,sha256=ZN7H57N8SfZmgvWqH-nXE5wK5wAMUBkMMhMFkkfXWI0,182
-wiz_trader/apis/__init__.py,sha256=ItWKMOl4omiW0g2f-M7WRW3v-dss_ULd9vYnFyIIT9o,132
-wiz_trader/apis/client.py,sha256=4Vu9z0cLjJ62LTNT13UwicU0Ez3jnwQOcirWtJAF4Hw,25578
-wiz_trader/quotes/__init__.py,sha256=RF9g9CNP6bVWlmCh_ad8krm3-EWOIuVfLp0-H9fAeEM,108
-wiz_trader/quotes/client.py,sha256=4djU1YgXuyhsWW-bgkI46BzK31PJlcrKXtxViVusEtY,13192
-wiz_trader-0.10.0.dist-info/METADATA,sha256=Cn4OhgEZtR9ih-7S2RuCiH7l3hcTF2-yWHZ05uojhF8,54894
-wiz_trader-0.10.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-wiz_trader-0.10.0.dist-info/top_level.txt,sha256=lnYS_g8LlA6ryKYnvY8xIQ6K2K-xzOsd-99AWgnW6VY,11
-wiz_trader-0.10.0.dist-info/RECORD,,