quantplay 2.0.36__tar.gz → 2.0.37__tar.gz

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

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

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

@@ -1,4 +1,3 @@
-from ast import alias
 import codecs
 import pickle
 import traceback

{quantplay-2.0.36 → 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:
@@ -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.36 → quantplay-2.0.37}/quantplay/broker/xts_utils/Connect.py

@@ -20,7 +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 ExchangeSegmentType
+from quantplay.model.xts import (
+    XTSTypes,
+)
 
 log = logging.getLogger(__name__)
 
@@ -240,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"""
@@ -280,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:
@@ -348,13 +350,13 @@ class XTSConnect(XTSCommon):
     def modify_order(
         self,
         appOrderID: int,
-        modifiedProductType,
-        modifiedOrderType,
+        modifiedProductType: XTSTypes.ProductType,
+        modifiedOrderType: XTSTypes.OrderType,
         modifiedOrderQuantity: int,
         modifiedDisclosedQuantity: int,
         modifiedLimitPrice: float,
         modifiedStopPrice: float,
-        modifiedTimeInForce,
+        modifiedTimeInForce: XTSTypes.DayOrNetType,
         orderUniqueIdentifier: str,
         clientID: str | None = None,
     ):
@@ -440,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
@@ -486,7 +488,9 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("cancel_order Failed for XTS")
 
-    def cancelall_order(self, exchangeSegment: ExchangeSegmentType, 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] = {
@@ -503,15 +507,15 @@ class XTSConnect(XTSCommon):
 
     def place_cover_order(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        orderSide,
-        orderType,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int,
+        orderSide: XTSTypes.OrderSide,
+        orderType: XTSTypes.OrderType,
         orderQuantity: int,
         disclosedQuantity: int,
         limitPrice: float,
         stopPrice: float,
-        orderUniqueIdentifier,
+        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
@@ -553,9 +557,9 @@ class XTSConnect(XTSCommon):
 
     def squareoff_position(
         self,
-        exchangeSegment,
-        exchangeInstrumentID,
-        productType,
+        exchangeSegment: XTSTypes.ExchangeType,
+        exchangeInstrumentID: int,
+        productType: XTSTypes.ProductType,
         squareoffMode,
         positionSquareOffQuantityType,
         squareOffQtyValue,
@@ -642,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,
@@ -654,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,
@@ -666,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,
@@ -678,7 +695,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("send_unsubscription Failed for XTS")
 
-    def get_master(self, exchangeSegmentList: List[ExchangeSegmentType]):
+    def get_master(self, exchangeSegmentList: List[XTSTypes.ExchangeType]):
         try:
             params: Dict[str, Any] = {"exchangeSegmentList": exchangeSegmentList}
             response = self._post("market.instruments.master", json.dumps(params))
@@ -689,11 +706,11 @@ class XTSConnect(XTSCommon):
 
     def get_ohlc(
         self,
-        exchangeSegment: ExchangeSegmentType,
-        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] = {
@@ -709,7 +726,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_ohlc Failed for XTS")
 
-    def get_series(self, exchangeSegment: ExchangeSegmentType):
+    def get_series(self, exchangeSegment: XTSTypes.ExchangeSegmentType):
         try:
             params: Dict[str, Any] = {"exchangeSegment": exchangeSegment}
             response = self._get("market.instruments.instrument.series", params)
@@ -718,7 +735,12 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_series Failed for XTS")
 
-    def get_equity_symbol(self, exchangeSegment: ExchangeSegmentType, series, symbol):
+    def get_equity_symbol(
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -731,7 +753,12 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_equity_symbol Failed for XTS")
 
-    def get_expiry_date(self, exchangeSegment: ExchangeSegmentType, series, symbol):
+    def get_expiry_date(
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -745,7 +772,11 @@ class XTSConnect(XTSCommon):
             raise BrokerException("get_expiry_date Failed for XTS")
 
     def get_future_symbol(
-        self, exchangeSegment: ExchangeSegmentType, series, symbol, expiryDate
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+        expiryDate: str,
     ):
         try:
             params: Dict[str, Any] = {
@@ -762,12 +793,12 @@ class XTSConnect(XTSCommon):
 
     def get_option_symbol(
         self,
-        exchangeSegment: ExchangeSegmentType,
-        series,
-        symbol,
-        expiryDate,
-        optionType,
-        strikePrice,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+        expiryDate: str,
+        optionType: Literal["CE", "PE"],
+        strikePrice: int,
     ):
         try:
             params: Dict[str, Any] = {
@@ -785,7 +816,11 @@ class XTSConnect(XTSCommon):
             raise BrokerException("get_option_symbol Failed for XTS")
 
     def get_option_type(
-        self, exchangeSegment: ExchangeSegmentType, series, symbol, expiryDate
+        self,
+        exchangeSegment: XTSTypes.ExchangeSegmentType,
+        series: XTSTypes.SeriesType,
+        symbol: str,
+        expiryDate: str,
     ):
         try:
             params: Dict[str, Any] = {
@@ -800,7 +835,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_option_type Failed for XTS")
 
-    def get_index_list(self, exchangeSegment: ExchangeSegmentType):
+    def get_index_list(self, exchangeSegment: XTSTypes.ExchangeSegmentType):
         try:
             params: Dict[str, Any] = {"exchangeSegment": exchangeSegment}
             response = self._get("market.instruments.indexlist", params)
@@ -809,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.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.36 → quantplay-2.0.37}/quantplay.egg-info/PKG-INFO

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

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

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

quantplay-2.0.36/quantplay/model/xts.py

@@ -1,7 +0,0 @@
-from typing import Literal
-
-
-ExchangeSegmentType = Literal[1, 2, 3, 11, 12]
-XTSMessageCodeType = Literal[1501, 1502, 1505, 1507, 1510, 1512, 1105]
-PublishFormatType = Literal["JSON", "Binary"]
-ExchangeType = Literal["NSECM", "NSEFO", "NSECD", "BSECM", "BSEFO"]