quantplay 2.0.35__tar.gz → 2.0.37__tar.gz

{quantplay-2.0.35 → quantplay-2.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.35
+Version: 2.0.37
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 

{quantplay-2.0.35 → quantplay-2.0.37}/quantplay/broker/five_paisa.py

@@ -147,9 +147,8 @@ class FivePaisa(Broker):
         return self.client.fetch_market_feed_scrip(req_list_)["Data"][0]["LastRate"]  # type: ignore
 
     def add_exchange(self, data: pl.DataFrame):
-        data["exchange"] = None
-
         return data.with_columns(
+            pl.lit(None).alias("exchange"),
             pl.when((pl.col("Exch").eq("N")) & (pl.col("ExchType").eq("D")))
             .then(pl.lit("NFO"))
             .alias("exchange"),

{quantplay-2.0.35 → quantplay-2.0.37}/quantplay/broker/xts.py

@@ -4,7 +4,7 @@ import pickle
 import traceback
 from datetime import datetime
 from queue import Queue
-from typing import Dict
+from typing import Any, Dict, List
 
 import pandas as pd
 import polars as pl
@@ -27,6 +27,7 @@ from quantplay.model.broker import (
 )
 from quantplay.model.generics import OrderTypeType, ProductType, TransactionType
 from quantplay.model.order_event import OrderUpdateEvent
+from quantplay.model.xts import XTSTypes
 from quantplay.utils.constant import Constants, OrderType
 from quantplay.utils.pickle_utils import InstrumentData, PickleUtils
 
@@ -151,7 +152,7 @@ class XTS(Broker):
         except Exception:
             raise InvalidArgumentException("Invalid api key/secret")
 
-    def handle_exception(self, response):
+    def handle_exception(self, response: Dict[str, Any]):
         if "data" in response and "description" in response["data"]:
             data = response["data"]
             if "max limit" in data["description"].lower():
@@ -164,7 +165,7 @@ class XTS(Broker):
         ):
             raise TokenException(response["description"])
         if "type" in response and response["type"] == "error":
-            raise Exception(f"[XTS_Error]: {response["description"]}")
+            raise Exception(f"[XTS_Error]: {response['description']}")
 
     @retry(
         wait_exponential_multiplier=3000,
@@ -463,15 +464,15 @@ class XTS(Broker):
 
         return positions_df
 
-    def get_quantplay_symbol(self, symbol):
+    def get_quantplay_symbol(self, symbol: str):
         if symbol in self.broker_symbol_map:
             return self.broker_symbol_map[symbol]
         return symbol
 
-    def get_ltps(self, symbols):
-        instruments = [
+    def get_ltps(self, symbols: List[str]):
+        instruments: List[XTSTypes.InstrumentType] = [
             {
-                "exchangeSegment": int(self.get_exchange_code(x.split(":")[0])),
+                "exchangeSegment": self.get_exchange_code(x.split(":")[0]),
                 "exchangeInstrumentID": int(x.split(":")[1]),
             }
             for x in symbols
@@ -493,8 +494,8 @@ class XTS(Broker):
         ltp = {x["ExchangeInstrumentID"]: float(x["LastTradedPrice"]) for x in ltp}
         return ltp
 
-    def get_exchange_code(self, exchange):
-        exchange_code_map = {
+    def get_exchange_code(self, exchange) -> XTSTypes.ExchangeSegmentType:
+        exchange_code_map: Dict[str, XTSTypes.ExchangeSegmentType] = {
             "NSE": 1,
             "NFO": 2,
             "BFO": 12,
@@ -513,8 +514,8 @@ class XTS(Broker):
 
         return exchange_code_map[exchange]
 
-    def get_exchange_name(self, exchange):
-        exchange_code_map = {
+    def get_exchange_name(self, exchange) -> XTSTypes.ExchangeType:
+        exchange_code_map: Dict[str, XTSTypes.ExchangeType] = {
             "NSE": "NSECM",
             "NFO": "NSEFO",
             "BFO": "BSEFO",
@@ -530,10 +531,11 @@ class XTS(Broker):
 
         return exchange_code_map[exchange]
 
-    def ltp(self, exchange=None, tradingsymbol=None) -> float:
+    def ltp(self, exchange, tradingsymbol: str) -> float:
         exchange_code = self.get_exchange_code(exchange)
         exchange_token = self.symbol_data[f"{exchange}:{tradingsymbol}"].get(
-            "exchange_token"
+            "exchange_token",
+            "",  # TODO
         )
 
         api_response = self.md_wrapper.get_quote(
@@ -580,11 +582,14 @@ class XTS(Broker):
         xts_order_type = self.get_order_type(order_type)
 
         exchange_token = self.symbol_data[f"{exchange}:{tradingsymbol}"].get(
-            "exchange_token"
+            "exchange_token", ""
         )
         if trigger_price is None:
             trigger_price = 0
 
+        if tag is None:
+            tag = ""
+
         api_response = self.wrapper.place_order(
             exchangeSegment=exchange_name,
             exchangeInstrumentID=exchange_token,
@@ -608,7 +613,7 @@ class XTS(Broker):
 
         return api_response["result"]["AppOrderID"]
 
-    def cancel_order(self, order_id, variety=None):
+    def cancel_order(self, order_id, variety: str | None = None):
         orders = self.orders()
 
         order_data = orders.filter(pl.col("order_id").eq(str(order_id)))
@@ -631,7 +636,7 @@ class XTS(Broker):
 
         return api_response["result"]["AppOrderID"]
 
-    def get_order_type(self, order_type: OrderTypeType) -> str:
+    def get_order_type(self, order_type: OrderTypeType):
         if order_type == OrderType.market:
             return "Market"
         elif order_type == OrderType.sl:
@@ -668,7 +673,7 @@ class XTS(Broker):
         disclosed_quantity = 0
 
         api_response = self.wrapper.modify_order(
-            appOrderID=order_id,
+            appOrderID=int(order_id),
             modifiedTimeInForce=time_in_force,
             modifiedDisclosedQuantity=disclosed_quantity,
             modifiedLimitPrice=price,
@@ -687,7 +692,9 @@ class XTS(Broker):
 
         return api_response["result"]["AppOrderID"]
 
-    def modify_price(self, order_id, price: float, trigger_price=None, order_type=None):
+    def modify_price(
+        self, order_id, price: float, trigger_price: float | None = None, order_type=None
+    ):
         self.modify_order(
             {
                 "order_id": str(order_id),

{quantplay-2.0.35 → quantplay-2.0.37}/quantplay/broker/xts_utils/Connect.py

@@ -9,7 +9,7 @@ import json
 import logging
 import os
 import traceback
-from typing import Any, Dict, Literal
+from typing import Any, Dict, List, Literal
 
 import requests
 import urllib3
@@ -20,6 +20,9 @@ from six.moves.urllib.parse import urljoin  # type:ignore
 from quantplay.broker.xts_utils import Exception as ex
 from quantplay.broker.xts_utils.Exception import XTSDataException
 from quantplay.exception.exceptions import BrokerException
+from quantplay.model.xts import (
+    XTSTypes,
+)
 
 log = logging.getLogger(__name__)
 
@@ -239,17 +242,17 @@ class XTSConnect(XTSCommon):
 
     def place_order(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        productType,
-        orderType,
-        orderSide,
-        timeInForce,
-        disclosedQuantity,
-        orderQuantity,
-        limitPrice,
-        stopPrice,
-        orderUniqueIdentifier,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int | str,
+        productType: XTSTypes.ProductType,
+        orderType: XTSTypes.OrderType,
+        orderSide: XTSTypes.OrderSide,
+        timeInForce: XTSTypes.DayOrNetType,
+        disclosedQuantity: int,
+        orderQuantity: int,
+        limitPrice: float,
+        stopPrice: float,
+        orderUniqueIdentifier: str,
         clientID: str | None = None,
     ):
         """To place an order"""
@@ -279,18 +282,18 @@ class XTSConnect(XTSCommon):
 
     def place_bracketorder(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        orderType,
-        orderSide,
-        disclosedQuantity,
-        orderQuantity,
-        limitPrice,
-        squarOff,
-        stopLossPrice,
-        trailingStoploss,
-        isProOrder,
-        orderUniqueIdentifier,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int,
+        orderType: XTSTypes.OrderType,
+        orderSide: XTSTypes.OrderSide,
+        disclosedQuantity: int,
+        orderQuantity: int,
+        limitPrice: float,
+        squarOff: int,
+        stopLossPrice: float,
+        trailingStoploss: float,
+        isProOrder: bool,
+        orderUniqueIdentifier: str,
     ):
         """To place a bracketorder"""
         try:
@@ -346,15 +349,15 @@ class XTSConnect(XTSCommon):
 
     def modify_order(
         self,
-        appOrderID,
-        modifiedProductType,
-        modifiedOrderType,
-        modifiedOrderQuantity,
-        modifiedDisclosedQuantity,
-        modifiedLimitPrice,
-        modifiedStopPrice,
-        modifiedTimeInForce,
-        orderUniqueIdentifier,
+        appOrderID: int,
+        modifiedProductType: XTSTypes.ProductType,
+        modifiedOrderType: XTSTypes.OrderType,
+        modifiedOrderQuantity: int,
+        modifiedDisclosedQuantity: int,
+        modifiedLimitPrice: float,
+        modifiedStopPrice: float,
+        modifiedTimeInForce: XTSTypes.DayOrNetType,
+        orderUniqueIdentifier: str,
         clientID: str | None = None,
     ):
         """The facility to modify your open orders by allowing you to change limit order to market or vice versa,
@@ -439,12 +442,12 @@ class XTSConnect(XTSCommon):
 
     def convert_position(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        targetQty,
-        isDayWise,
-        oldProductType,
-        newProductType,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int,
+        targetQty: int,
+        isDayWise: bool,
+        oldProductType: XTSTypes.ProductType,
+        newProductType: XTSTypes.ProductType,
         clientID: str | None = None,
     ):
         """Convert position API, enable users to convert their open positions from NRML intra-day to Short term MIS or
@@ -468,7 +471,7 @@ class XTSConnect(XTSCommon):
             raise BrokerException("convert_position Failed for XTS")
 
     def cancel_order(
-        self, appOrderID, orderUniqueIdentifier, clientID: str | None = None
+        self, appOrderID: int, orderUniqueIdentifier: str, clientID: str | None = None
     ):
         """This API can be called to cancel any open order of the user by providing correct appOrderID matching with
         the chosen open order to cancel."""
@@ -485,7 +488,9 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("cancel_order Failed for XTS")
 
-    def cancelall_order(self, exchangeSegment, exchangeInstrumentID):
+    def cancelall_order(
+        self, exchangeSegment: XTSTypes.ExchangeSegmentType, exchangeInstrumentID: int
+    ):
         """This API can be called to cancel all open order of the user by providing exchange segment and exchange instrument ID"""
         try:
             params: Dict[str, Any] = {
@@ -502,15 +507,15 @@ class XTSConnect(XTSCommon):
 
     def place_cover_order(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        orderSide,
-        orderType,
-        orderQuantity,
-        disclosedQuantity,
-        limitPrice,
-        stopPrice,
-        orderUniqueIdentifier,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int,
+        orderSide: XTSTypes.OrderSide,
+        orderType: XTSTypes.OrderType,
+        orderQuantity: int,
+        disclosedQuantity: int,
+        limitPrice: float,
+        stopPrice: float,
+        orderUniqueIdentifier: str,
         clientID: str | None = None,
     ):
         """A Cover Order is an advance intraday order that is accompanied by a compulsory Stop Loss Order. This helps
@@ -537,7 +542,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("place_cover_order Failed for XTS")
 
-    def exit_cover_order(self, appOrderID, clientID: str | None = None):
+    def exit_cover_order(self, appOrderID: int, clientID: str | None = None):
         """Exit Cover API is a functionality to enable user to easily exit an open stoploss order by converting it
         into Exit order."""
         try:
@@ -552,9 +557,9 @@ class XTSConnect(XTSCommon):
 
     def squareoff_position(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        productType,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int,
+        productType: XTSTypes.ProductType,
         squareoffMode,
         positionSquareOffQuantityType,
         squareOffQtyValue,
@@ -583,7 +588,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("squareoff_position Failed for XTS")
 
-    def get_order_history(self, appOrderID, clientID: str | None = None):
+    def get_order_history(self, appOrderID: int, clientID: str | None = None):
         """Order history will provide particular order trail chain. This indicate the particular order & its state
         changes. i.e.Pending New to New, New to PartiallyFilled, PartiallyFilled, PartiallyFilled & PartiallyFilled
         to Filled etc"""
@@ -641,7 +646,12 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_config Failed for XTS")
 
-    def get_quote(self, Instruments, xtsMessageCode, publishFormat):
+    def get_quote(
+        self,
+        Instruments: List[XTSTypes.InstrumentType],
+        xtsMessageCode: XTSTypes.XTSMessageCodeType,
+        publishFormat: XTSTypes.PublishFormatType,
+    ):
         try:
             params: Dict[str, Any] = {
                 "instruments": Instruments,
@@ -653,7 +663,11 @@ class XTSConnect(XTSCommon):
         except Exception as e:
             raise e
 
-    def send_subscription(self, Instruments, xtsMessageCode):
+    def send_subscription(
+        self,
+        Instruments: List[XTSTypes.InstrumentType],
+        xtsMessageCode: XTSTypes.XTSMessageCodeType,
+    ):
         try:
             params: Dict[str, Any] = {
                 "instruments": Instruments,
@@ -665,7 +679,11 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("send_subscription Failed for XTS")
 
-    def send_unsubscription(self, Instruments, xtsMessageCode):
+    def send_unsubscription(
+        self,
+        Instruments: List[XTSTypes.InstrumentType],
+        xtsMessageCode: XTSTypes.XTSMessageCodeType,
+    ):
         try:
             params: Dict[str, Any] = {
                 "instruments": Instruments,
@@ -677,7 +695,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("send_unsubscription Failed for XTS")
 
-    def get_master(self, exchangeSegmentList):
+    def get_master(self, exchangeSegmentList: List[XTSTypes.ExchangeType]):
         try:
             params: Dict[str, Any] = {"exchangeSegmentList": exchangeSegmentList}
             response = self._post("market.instruments.master", json.dumps(params))
@@ -688,11 +706,11 @@ class XTSConnect(XTSCommon):
 
     def get_ohlc(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        startTime,
-        endTime,
-        compressionValue,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        exchangeInstrumentID: str | int,
+        startTime: str,
+        endTime: str,
+        compressionValue: Literal[1, 60, 120, 180, 300, 600, 900, 1800, 3600],
     ):
         try:
             params: Dict[str, Any] = {
@@ -708,7 +726,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_ohlc Failed for XTS")
 
-    def get_series(self, exchangeSegment):
+    def get_series(self, exchangeSegment: XTSTypes.ExchangeSegmentType):
         try:
             params: Dict[str, Any] = {"exchangeSegment": exchangeSegment}
             response = self._get("market.instruments.instrument.series", params)
@@ -717,7 +735,12 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_series Failed for XTS")
 
-    def get_equity_symbol(self, exchangeSegment, series, symbol):
+    def get_equity_symbol(
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -730,7 +753,12 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_equity_symbol Failed for XTS")
 
-    def get_expiry_date(self, exchangeSegment, series, symbol):
+    def get_expiry_date(
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -743,7 +771,13 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_expiry_date Failed for XTS")
 
-    def get_future_symbol(self, exchangeSegment, series, symbol, expiryDate):
+    def get_future_symbol(
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+        expiryDate: str,
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -758,7 +792,13 @@ class XTSConnect(XTSCommon):
             raise BrokerException("get_future_symbol Failed for XTS")
 
     def get_option_symbol(
-        self, exchangeSegment, series, symbol, expiryDate, optionType, strikePrice
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+        expiryDate: str,
+        optionType: Literal["CE", "PE"],
+        strikePrice: int,
     ):
         try:
             params: Dict[str, Any] = {
@@ -775,7 +815,13 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_option_symbol Failed for XTS")
 
-    def get_option_type(self, exchangeSegment, series, symbol, expiryDate):
+    def get_option_type(
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+        expiryDate: str,
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -789,7 +835,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_option_type Failed for XTS")
 
-    def get_index_list(self, exchangeSegment):
+    def get_index_list(self, exchangeSegment: XTSTypes.ExchangeSegmentType):
         try:
             params: Dict[str, Any] = {"exchangeSegment": exchangeSegment}
             response = self._get("market.instruments.indexlist", params)
@@ -798,7 +844,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_index_list Failed for XTS")
 
-    def search_by_instrumentid(self, Instruments):
+    def search_by_instrumentid(self, Instruments: List[XTSTypes.InstrumentType]):
         try:
             params: Dict[str, Any] = {"source": self.source, "instruments": Instruments}
             response = self._post("market.search.instrumentsbyid", json.dumps(params))

{quantplay-2.0.35 → quantplay-2.0.37}/quantplay/broker/xts_utils/InteractiveSocketClient.py

@@ -1,5 +1,5 @@
-from typing import Dict, List, Literal
-import socketio
+from typing import Any, Dict, List, Literal
+import socketio  # type: ignore
 
 
 class OrderSocket_io(socketio.Client):
@@ -48,8 +48,8 @@ class OrderSocket_io(socketio.Client):
         randomization_factor: float = 0.5,
         logger: bool = False,
         binary: bool = False,
-        json=None,
-        **kwargs,
+        json: Any | None = None,
+        **kwargs: Any,
     ):
         self.sid = socketio.Client(logger=False, engineio_logger=False)
         self.eventlistener = self.sid
@@ -65,17 +65,17 @@ class OrderSocket_io(socketio.Client):
             port + self.token + "&userID=" + self.userID + "&apiType=INTERACTIVE"
         )
 
-    def setup_event_listners(self, on_order):
-        self.sid.on("order", on_order)
+    def setup_event_listners(self, on_order: Any):
+        self.sid.on("order", on_order)  # type: ignore
 
         # self.sid.on("connect", self.on_connect)
-        self.sid.on("message", self.on_message)
+        self.sid.on("message", self.on_message)  # type: ignore
         # self.sid.on("joined", self.on_joined)
-        self.sid.on("error", self.on_error)
-        self.sid.on("trade", self.on_trade)
-        self.sid.on("position", self.on_position)
-        self.sid.on("tradeConversion", self.on_tradeconversion)
-        self.sid.on("logout", self.on_messagelogout)
+        self.sid.on("error", self.on_error)  # type: ignore
+        self.sid.on("trade", self.on_trade)  # type: ignore
+        self.sid.on("position", self.on_position)  # type: ignore
+        self.sid.on("tradeConversion", self.on_tradeconversion)  # type: ignore
+        self.sid.on("logout", self.on_messagelogout)  # type: ignore
         # self.sid.on("disconnect", self.on_disconnect)
 
     def connect(  # type: ignore
@@ -108,7 +108,7 @@ class OrderSocket_io(socketio.Client):
         url = self.connection_url
 
         """Connected to the socket."""
-        self.sid.connect(url, headers, transports, namespaces, socketio_path)
+        self.sid.connect(url, headers, transports, namespaces, socketio_path)  # type: ignore
         self.sid.wait()
         """Disconnect from the socket."""
         # self.sid.disconnect()
@@ -121,33 +121,33 @@ class OrderSocket_io(socketio.Client):
         """On message from socket"""
         print("I received a message!")
 
-    def on_joined(self, data):
+    def on_joined(self, data: Any):
         """On socket joined"""
-        print("Interactive socket joined successfully!" + data)
+        print(f"Interactive socket joined successfully!{data}")
 
-    def on_error(self, data):
+    def on_error(self, data: Any):
         """On receiving error from socket"""
-        print("Interactive socket error!" + data)
+        print(f"Interactive socket error!{data}")
 
-    def on_order(self, data):
+    def on_order(self, data: Any):
         """On receiving order placed data from socket"""
-        print("Order placed!" + data)
+        print(f"Order placed!{data}")
 
-    def on_trade(self, data):
+    def on_trade(self, data: Any):
         """On receiving trade data from socket"""
-        print("Trade Received!" + data)
+        print(f"Trade Received!{data}")
 
-    def on_position(self, data):
+    def on_position(self, data: Any):
         """On receiving position data from socket"""
-        print("Position Retrieved!" + data)
+        print(f"Position Retrieved!{data}")
 
-    def on_tradeconversion(self, data):
+    def on_tradeconversion(self, data: Any):
         """On receiving trade conversion data from socket"""
-        print("Trade Conversion Received!" + data)
+        print(f"Trade Conversion Received!{data}")
 
-    def on_messagelogout(self, data):
+    def on_messagelogout(self, data: Any):
         """On receiving user logout message"""
-        print("User logged out!" + data)
+        print(f"User logged out!{data}")
 
     def on_disconnect(self):
         """On receiving disconnection from socket"""

quantplay-2.0.37/quantplay/model/xts.py

@@ -0,0 +1,24 @@
+from typing import Literal, TypedDict
+
+
+XTSExchangeSegmentType = Literal[1, 2, 3, 11, 12]
+
+
+class XTSInstrumentType(TypedDict):
+    exchangeSegment: XTSExchangeSegmentType
+    exchangeInstrumentID: str | int
+
+
+class XTSTypes:
+    ExchangeSegmentType = XTSExchangeSegmentType
+    XTSMessageCodeType = Literal[1501, 1502, 1505, 1507, 1510, 1512, 1105]
+    PublishFormatType = Literal["JSON", "Binary"]
+    ExchangeType = Literal["NSECM", "NSEFO", "NSECD", "BSECM", "BSEFO"]
+    InstrumentType = XTSInstrumentType
+    SeriesType = str
+    OrderSide = Literal["BUY", "SELL"]
+    OrderType = Literal["Market", "StopLimit", "StopMarket", "Limit"]
+    ProductType = Literal["CO", "CNC", "MIS", "NRML"]
+    PositionSqureOffModeType = Literal["DayWise", "NetWise"]
+    PositionSquareOffQuantityTypeType = Literal["Percentage", "ExactQty"]
+    DayOrNetType = Literal["DAY", "NET"]

{quantplay-2.0.35 → quantplay-2.0.37}/quantplay.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.35
+Version: 2.0.37
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 

{quantplay-2.0.35 → quantplay-2.0.37}/quantplay.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ quantplay/model/broker.py
 quantplay/model/generics.py
 quantplay/model/instrument_data.py
 quantplay/model/order_event.py
+quantplay/model/xts.py
 quantplay/utils/__init__.py
 quantplay/utils/constant.py
 quantplay/utils/exchange.py

{quantplay-2.0.35 → quantplay-2.0.37}/setup.py

@@ -21,7 +21,7 @@ requirements = [
 setup(
     name="quantplay",
     long_description=Path("README.md").read_text(),
-    version="2.0.35",
+    version="2.0.37",
     setup_requires=["pytest-runner"],
     install_requires=requirements,
     tests_require=[],