wiz-trader 0.13.0__tar.gz → 0.15.0__tar.gz

{wiz_trader-0.13.0/src/wiz_trader.egg-info → wiz_trader-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.13.0
+Version: 0.15.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.13.0 → wiz_trader-0.15.0}/pyproject.toml

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

{wiz_trader-0.13.0 → wiz_trader-0.15.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
   name='wiz_trader',
-  version='0.13.0',
+  version='0.15.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.13.0 → wiz_trader-0.15.0}/src/wiz_trader/__init__.py

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

{wiz_trader-0.13.0 → wiz_trader-0.15.0}/src/wiz_trader/apis/client.py

@@ -61,11 +61,29 @@ class WizzerClient:
   SEGMENT_BSE_CM = "BSECM"    # BSE Cash Market
   SEGMENT_NSE_FO = "NSEFO"    # NSE Futures and Options
   SEGMENT_WZREQ = "WZREQ"     # Wizzer Basket Segment
+  
+  # Order status constants
+  ORDER_STATUS_OPEN = "OPEN"
+  ORDER_STATUS_CANCELLED = "CANCELLED" 
+  ORDER_STATUS_REJECTED = "REJECTED"
+  ORDER_STATUS_PENDING = "PENDING"
+  ORDER_STATUS_COMPLETED = "COMPLETED"
+
+  # Trading mode constants
+  TRADING_MODE_PAPER = "paper_trading"
+  TRADING_MODE_ADVICES = "advices"
+  TRADING_MODE_TRADING_AND_ADVICES = "trading_and_advices"
+  
+  # Rebalance execution policies
+  REBALANCE_FULL = "full_rebalance"
+  REBALANCE_ENTRY_ONLY = "entry_only"
+  REBALANCE_EXIT_ONLY = "exit_only"
 
   # URIs to various API endpoints
   _routes = {
     # Order related endpoints
     "order.place": "/orders",
+    "order.get": "/orders",
     "order.modify": "/orders/{order_id}",
     "order.cancel": "/orders/{order_id}",
     "order.info": "/orders/{order_id}",
@@ -92,6 +110,9 @@ class WizzerClient:
     "datahub.indices": "/datahub/indices",
     "datahub.index.components": "/datahub/index/components",
     "datahub.historical.ohlcv": "/datahub/historical/ohlcv",
+    
+    # Instrument & asset class endpoints
+    "instrument.metrics": "/instruments/metrics",
   }
   
   def __init__(
@@ -241,7 +262,6 @@ class WizzerClient:
     variety: str = None,
     stoploss: float = 0,
     target: float = 0,
-    segment: Optional[str] = None,
     exchange_token: Optional[int] = None,
     broker: str = None,
     strategy: Optional[Dict[str, str]] = None
@@ -283,16 +303,6 @@ class WizzerClient:
     if variety is None:
       variety = self.VARIETY_REGULAR
     
-    # Determine segment if not provided
-    if not segment:
-      segment = f"{exchange}CM"
-      # If exchange is NSE, use the NSE_CM constant
-      if exchange == self.EXCHANGE_NSE:
-        segment = self.SEGMENT_NSE_CM
-      # If exchange is BSE, use the BSE_CM constant
-      elif exchange == self.EXCHANGE_BSE:
-        segment = self.SEGMENT_BSE_CM
-    
     # Get strategy information
     strategy_info = self._get_strategy(strategy)
     
@@ -310,7 +320,6 @@ class WizzerClient:
       "variety": variety,
       "stoploss": stoploss,
       "target": target,
-      "segment": segment,
       "strategy": strategy_info
     }
     
@@ -319,7 +328,7 @@ class WizzerClient:
       data["exchangeToken"] = exchange_token
         
     logger.debug("Placing order: %s", data)
-    return self._make_request("POST", self._routes["order.place"], json=data)
+    return self._make_request("POST", endpoint, json=data)
     
   def modify_order(
     self,
@@ -355,7 +364,480 @@ class WizzerClient:
     
     logger.debug("Cancelling order: %s", order_id)
     return self._make_request("DELETE", endpoint)
-    
+
+  def get_orders(
+      self,
+      trading_modes: Optional[List[str]] = None,
+      order_statuses: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      page_no: int = 1,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get orders with optional filtering.
+      
+      Args:
+          trading_modes (Optional[List[str]], optional): Filter by trading modes.
+              Valid values: "paper_trading", "advices", "trading_and_advices".
+          order_statuses (Optional[List[str]], optional): Filter by order statuses.
+              Valid values: "OPEN", "CANCELLED", "REJECTED", "PENDING", "COMPLETED".
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format. Defaults to today.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format. Defaults to today.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          page_no (int, optional): Page number for pagination. Defaults to 1.
+          paginate (bool, optional): Whether to automatically fetch all pages. Defaults to False.
+              
+      Returns:
+          List[Dict[str, Any]]: List of orders matching the filter criteria.
+      """
+      endpoint = self._routes["order.get"]
+      
+      # Build the base parameters without list items
+      params = {}
+      
+      # Handle single parameters
+      if from_date:
+          params["fromDateRange"] = from_date
+      
+      if to_date:
+          params["toDateRange"] = to_date
+      
+      if not paginate:
+          params["pageNo"] = page_no
+      
+      # Validate trading modes
+      if trading_modes:
+          for mode in trading_modes:
+              if mode not in [self.TRADING_MODE_PAPER, self.TRADING_MODE_ADVICES, self.TRADING_MODE_TRADING_AND_ADVICES]:
+                  raise ValueError(f"Invalid trading mode: {mode}")
+      
+      # Validate order statuses
+      if order_statuses:
+          for status in order_statuses:
+              if status not in [self.ORDER_STATUS_OPEN, self.ORDER_STATUS_CANCELLED, 
+                              self.ORDER_STATUS_REJECTED, self.ORDER_STATUS_PENDING, 
+                              self.ORDER_STATUS_COMPLETED]:
+                  raise ValueError(f"Invalid order status: {status}")
+      
+      # Handle pagination with properly formatted parameters
+      if paginate:
+          return self._paginate_orders(endpoint, params, trading_modes, order_statuses, trading_symbols)
+      else:
+          logger.debug("Fetching orders with params: %s", params)
+          return self._make_request_with_multi_params(
+              "GET", 
+              endpoint, 
+              params=params,
+              trading_modes=trading_modes,
+              order_statuses=order_statuses, 
+              trading_symbols=trading_symbols
+          )
+
+  def _make_request_with_multi_params(
+      self, 
+      method: str, 
+      endpoint: str, 
+      params: Dict[str, Any],
+      trading_modes: Optional[List[str]] = None,
+      order_statuses: Optional[List[str]] = None,
+      trading_symbols: Optional[List[str]] = None
+  ) -> Any:
+      """
+      Make an HTTP request with multiple parameters having the same name.
+      
+      Args:
+          method (str): HTTP method (GET, POST, etc.)
+          endpoint (str): API endpoint path.
+          params (Dict[str, Any]): Base query parameters.
+          trading_modes (Optional[List[str]]): List of trading modes.
+          order_statuses (Optional[List[str]]): List of order statuses.
+          trading_symbols (Optional[List[str]]): List of trading symbols.
+          
+      Returns:
+          Any: Parsed JSON response.
+      """
+      url = f"{self.base_url}{endpoint}"
+      
+      # Start with the base parameters
+      all_params = params.copy()
+      
+      # Create a session to manually handle parameter encoding
+      session = requests.Session()
+      req = requests.Request(method, url, headers=self.headers, params=all_params)
+      prepped = req.prepare()
+      
+      # Build the URL with additional repeated parameters
+      query_parts = []
+      if prepped.url.find('?') >= 0:
+          query_parts.append(prepped.url.split('?', 1)[1])
+      
+      # Add repeated parameters
+      if trading_modes:
+          for mode in trading_modes:
+              query_parts.append(f"tradingMode={mode}")
+      
+      if order_statuses:
+          for status in order_statuses:
+              query_parts.append(f"orderStatus={status}")
+      
+      if trading_symbols:
+          for symbol in trading_symbols:
+              query_parts.append(f"tradingSymbols={symbol}")
+      
+      # Build the final URL
+      final_url = prepped.url.split('?')[0]
+      if query_parts:
+          final_url += '?' + '&'.join(query_parts)
+      
+      try:
+          logger.debug("%s request to %s", method, final_url)
+          response = session.send(prepped)
+          response.url = final_url
+          response.raise_for_status()
+          return response.json()
+      except requests.RequestException as e:
+          logger.error("API request failed: %s", e, exc_info=True)
+          if hasattr(e.response, 'text'):
+              logger.error("Response content: %s", e.response.text)
+          raise
+
+  def _paginate_orders(
+      self, 
+      endpoint: str, 
+      params: Dict[str, Any],
+      trading_modes: Optional[List[str]] = None,
+      order_statuses: Optional[List[str]] = None,
+      trading_symbols: Optional[List[str]] = None
+  ) -> List[Dict[str, Any]]:
+      """
+      Internal method to handle pagination for orders API with multi-value parameters.
+      
+      Args:
+          endpoint (str): API endpoint.
+          params (Dict[str, Any]): Base query parameters.
+          trading_modes (Optional[List[str]]): List of trading modes.
+          order_statuses (Optional[List[str]]): List of order statuses.
+          trading_symbols (Optional[List[str]]): List of trading symbols.
+          
+      Returns:
+          List[Dict[str, Any]]: Combined results from all pages.
+      """
+      all_orders = []
+      page_no = 1
+      total_count = None
+      page_size = 50  # API returns 50 orders per page
+      
+      while True:
+          current_params = params.copy()
+          current_params["pageNo"] = page_no
+          logger.debug("Fetching orders page %d", page_no)
+          
+          # Build the URL with the session to get the properly formatted parameters
+          session = requests.Session()
+          req = requests.Request("GET", f"{self.base_url}{endpoint}", headers=self.headers, params=current_params)
+          prepped = req.prepare()
+          
+          # Build the URL with additional repeated parameters
+          query_parts = []
+          if prepped.url.find('?') >= 0:
+              query_parts.append(prepped.url.split('?', 1)[1])
+          
+          # Add repeated parameters
+          if trading_modes:
+              for mode in trading_modes:
+                  query_parts.append(f"tradingMode={mode}")
+          
+          if order_statuses:
+              for status in order_statuses:
+                  query_parts.append(f"orderStatus={status}")
+          
+          if trading_symbols:
+              for symbol in trading_symbols:
+                  query_parts.append(f"tradingSymbols={symbol}")
+          
+          # Build the final URL
+          final_url = prepped.url.split('?')[0]
+          if query_parts:
+              final_url += '?' + '&'.join(query_parts)
+          
+          # Make the request
+          try:
+              logger.debug("GET request to %s", final_url)
+              prepped.url = final_url
+              response = session.send(prepped)
+              response.raise_for_status()
+              
+              # Get orders from the current page
+              orders = response.json()
+              all_orders.extend(orders)
+              
+              # Check if we need to fetch more pages
+              if total_count is None and "X-Total-Count" in response.headers:
+                  try:
+                      total_count = int(response.headers["X-Total-Count"])
+                      logger.debug("Total orders count: %d", total_count)
+                  except (ValueError, TypeError):
+                      logger.warning("Could not parse X-Total-Count header")
+                      break
+              
+              # If we've fetched all orders or there are no more pages, stop
+              if not orders or len(all_orders) >= total_count or total_count is None:
+                  break
+              
+              # Move to the next page
+              page_no += 1
+              
+          except requests.RequestException as e:
+              logger.error("API request failed during pagination: %s", e, exc_info=True)
+              if hasattr(e.response, 'text'):
+                  logger.error("Response content: %s", e.response.text)
+              raise
+      
+      logger.info("Fetched %d orders in total", len(all_orders))
+      return all_orders
+
+  def get_open_orders(
+      self,
+      trading_modes: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get open orders with optional filtering.
+      
+      Args:
+          trading_modes (Optional[List[str]], optional): Filter by trading modes.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of open orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=trading_modes,
+          order_statuses=[self.ORDER_STATUS_OPEN],
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_completed_orders(
+      self,
+      trading_modes: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get completed orders with optional filtering.
+      
+      Args:
+          trading_modes (Optional[List[str]], optional): Filter by trading modes.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of completed orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=trading_modes,
+          order_statuses=[self.ORDER_STATUS_COMPLETED],
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_pending_orders(
+      self,
+      trading_modes: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get pending orders with optional filtering.
+      
+      Args:
+          trading_modes (Optional[List[str]], optional): Filter by trading modes.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of pending orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=trading_modes,
+          order_statuses=[self.ORDER_STATUS_PENDING],
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_cancelled_orders(
+      self,
+      trading_modes: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get cancelled orders with optional filtering.
+      
+      Args:
+          trading_modes (Optional[List[str]], optional): Filter by trading modes.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of cancelled orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=trading_modes,
+          order_statuses=[self.ORDER_STATUS_CANCELLED],
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_rejected_orders(
+      self,
+      trading_modes: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get rejected orders with optional filtering.
+      
+      Args:
+          trading_modes (Optional[List[str]], optional): Filter by trading modes.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of rejected orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=trading_modes,
+          order_statuses=[self.ORDER_STATUS_REJECTED],
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_paper_traded_orders(
+      self,
+      order_statuses: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get paper traded orders with optional filtering.
+      
+      Args:
+          order_statuses (Optional[List[str]], optional): Filter by order statuses.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of paper traded orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=[self.TRADING_MODE_PAPER],
+          order_statuses=order_statuses,
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_advised_orders(
+      self,
+      order_statuses: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get advised orders with optional filtering.
+      
+      Args:
+          order_statuses (Optional[List[str]], optional): Filter by order statuses.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of advised orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=[self.TRADING_MODE_ADVICES],
+          order_statuses=order_statuses,
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+
+  def get_live_traded_orders(
+      self,
+      order_statuses: Optional[List[str]] = None,
+      from_date: Optional[str] = None,
+      to_date: Optional[str] = None,
+      trading_symbols: Optional[List[str]] = None,
+      paginate: bool = False
+  ) -> List[Dict[str, Any]]:
+      """
+      Get live traded orders with optional filtering.
+      
+      Args:
+          order_statuses (Optional[List[str]], optional): Filter by order statuses.
+          from_date (Optional[str], optional): Start date in YYYY-MM-DD format.
+          to_date (Optional[str], optional): End date in YYYY-MM-DD format.
+          trading_symbols (Optional[List[str]], optional): Filter by trading symbols.
+          paginate (bool, optional): Whether to automatically fetch all pages.
+              
+      Returns:
+          List[Dict[str, Any]]: List of live traded orders matching the filter criteria.
+      """
+      return self.get_orders(
+          trading_modes=[self.TRADING_MODE_TRADING_AND_ADVICES],
+          order_statuses=order_statuses,
+          from_date=from_date,
+          to_date=to_date,
+          trading_symbols=trading_symbols,
+          paginate=paginate
+      )
+  
   def get_order(self, order_id: str) -> Dict[str, Any]:
     """
     Get details of a specific order by ID.
@@ -682,7 +1164,8 @@ class WizzerClient:
   def rebalance_basket(
     self,
     trading_symbol: str,
-    instruments: List[str]
+    instruments: List[str],
+    execution_policy: str
   ) -> Dict[str, Any]:
     """
     Rebalance a basket with new instruments.
@@ -690,6 +1173,8 @@ class WizzerClient:
     Args:
       trading_symbol (str): Basket trading symbol.
       instruments (List[str]): List of instrument identifiers for the new basket composition.
+      execution_policy (str): Rebalance execution policy. 
+          Options: "full_rebalance", "entry_only", "exit_only".
         
     Returns:
       Dict[str, Any]: Rebalance response.
@@ -698,10 +1183,14 @@ class WizzerClient:
     
     data = {
       "tradingSymbol": trading_symbol,
-      "instruments": instruments
+      "instruments": instruments,
+      "policies": {
+        "execution": execution_policy
+      }
     }
     
-    logger.debug("Rebalancing basket %s with instruments: %s", trading_symbol, instruments)
+    logger.debug("Rebalancing basket %s with instruments: %s, policy: %s", 
+                 trading_symbol, instruments, execution_policy)
     return self._make_request("POST", endpoint, json=data)
     
   def exit_all_positions(self) -> Dict[str, Any]:
@@ -747,6 +1236,35 @@ class WizzerClient:
     logger.debug("Exiting all positions for strategy: %s", strategy_id)
     return self._make_request("POST", endpoint, json=data)
 
+  # =====INSTRUMENT & ASSET CLASS METHODS =====
+  
+  def get_instrument_metrics(self, identifiers: List[str]) -> List[Dict[str, Any]]:
+    """
+    Get detailed metrics for instruments by their identifiers.
+    
+    Args:
+        identifiers (List[str]): List of instrument identifiers in the format
+                                "EXCHANGE:SYMBOL:TOKEN" (e.g., "NSE:SBIN:3045").
+        
+    Returns:
+        List[Dict[str, Any]]: List of instrument metrics.
+    
+    Example:
+        >>> client.get_instrument_metrics([
+        ...     "NSE:SBIN:3045", 
+        ...     "NSE:RELIANCE:2885",
+        ...     "NSE:NIFTY26DEC11000CE:61009"
+        ... ])
+    """
+    endpoint = self._routes["instrument.metrics"]
+    data = {
+        "identifiers": identifiers
+    }
+    
+    logger.debug("Fetching instrument metrics for identifiers: %s", identifiers)
+    response = self._make_request("POST", endpoint, json=data)
+    return response
+
   def _make_request(
     self, 
     method: str, 

{wiz_trader-0.13.0 → wiz_trader-0.15.0/src/wiz_trader.egg-info}/PKG-INFO

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