quantplay 1.2.41__tar.gz → 1.2.46__tar.gz

{quantplay-1.2.41 → quantplay-1.2.46}/PKG-INFO

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

quantplay-1.2.46/quantplay/broker/iifl_xts.py

@@ -0,0 +1,16 @@
+from quantplay.broker.xts import XTS
+from quantplay.utils.constant import timeit
+
+
+class IIFL(XTS):
+    xts_interactive = "https://ttblaze.iifl.com"
+    xts_market = "https://ttblaze.iifl.com/apimarketdata"
+
+    @timeit(MetricName="Symphony:__init__")
+    def __init__(self, api_secret=None, api_key=None):
+        super().__init__(
+            api_secret=api_secret,
+            api_key=api_key,
+            root_interactive=self.xts_interactive,
+            root_market=self.xts_market,
+        )

quantplay-1.2.46/quantplay/broker/symphony.py

@@ -0,0 +1,16 @@
+from quantplay.broker.xts import XTS
+from quantplay.utils.constant import timeit
+
+
+class Symphony(XTS):
+    xts_interactive = "https://developers.symphonyfintech.in"
+    xts_market = "https://developers.symphonyfintech.in"
+
+    @timeit(MetricName="Symphony:__init__")
+    def __init__(self, api_secret=None, api_key=None):
+        super().__init__(
+            api_secret=api_secret,
+            api_key=api_key,
+            root_interactive=self.xts_interactive,
+            root_market=self.xts_market,
+        )

quantplay-1.2.46/quantplay/broker/xts.py

@@ -0,0 +1,263 @@
+import traceback
+import json
+
+from quantplay.broker.generics.broker import Broker
+from quantplay.utils.constant import Constants, timeit
+from quantplay.broker.xts_utils.Connect import XTSConnect
+
+
+class XTS(Broker):
+    source = "WebAPI"
+
+    @timeit(MetricName="XTS:__init__")
+    def __init__(
+        self,
+        api_secret,
+        api_key,
+        root_interactive,
+        root_market,
+    ):
+        super(XTS, self).__init__()
+
+        try:
+            self.wrapper = XTSConnect(
+                apiKey=api_key,
+                secretKey=api_secret,
+                source=self.source,
+                root_interactive=root_interactive,
+                root_market=root_market,
+            )
+            self.login()
+
+        except Exception as e:
+            print(traceback.print_exc())
+            raise e
+
+    def login(self):
+        response_interact = self.wrapper.interactive_login()
+        self.wrapper.marketdata_login()
+
+        self.ClientID = response_interact["result"]["clientCodes"][0]
+
+    def account_summary(self):
+        # TODO: Edit For Dealers
+
+        api_response = self.wrapper.get_balance(self.ClientID)
+
+        if not api_response:
+            raise Exception(
+                "[XTS_ERROR]: Balance API available for retail API users only, dealers can watch the same on dealer terminal"
+            )
+
+        api_response = api_response["result"]["BalanceList"][0]["limitObject"]
+
+        response = {
+            # TODO: Get PNL
+            "pnl": 0,
+            "margin_used": api_response["RMSSubLimits"]["marginUtilized"],
+            "margin_available": api_response["RMSSubLimits"]["netMarginAvailable"],
+        }
+
+        return response
+
+    def profile(self):
+        api_response = self.wrapper.get_profile(self.ClientID)["result"]
+
+        response = {
+            "user_id": api_response["ClientId"],
+            "full_name": api_response["ClientName"],
+            "segments": api_response["ClientExchangeDetailsList"],
+        }
+
+        return response
+
+    def orders(self):
+        # TODO: Transform into Quantplay
+        api_response = self.wrapper.get_order_book(self.ClientID)["result"]
+
+        return api_response
+
+    def positions(self):
+        # TODO: Transform into Quantplay
+        api_response = self.wrapper.get_position_daywise(self.ClientID)["result"]
+
+        return api_response
+
+    def get_symbol(self, exchange, symbol):
+        # TODO: Add Futures and Options
+
+        if exchange == 1:
+            response = self.wrapper.get_equity_symbol(
+                exchangeSegment=exchange, series="EQ", symbol=symbol
+            )
+
+            if response["type"] == "error":
+                raise Exception("[XTS_ERROR]: " + response["description"])
+
+            return response["result"][0]["ExchangeInstrumentID"]
+
+        elif exchange == 2:
+            # TODO: Ask
+            response = self.wrapper.get_option_symbol(
+                exchangeSegment=exchange, series="FUTIDX", symbol=symbol
+            )
+
+            if response["type"] == "error":
+                raise Exception("[XTS_ERROR]: " + response["description"])
+
+            return response["result"][0]["ExchangeInstrumentID"]
+
+        else:
+            raise Exception("UNSUPORTED_EXCHANGE: Exchange not in ['NSE', 'NFO']")
+
+    def get_exchange_code(self, exchange):
+        exchange_code_map = {
+            "NSE": 1,
+            "NFO": 2,
+            "NSECD": 3,
+            "BSECM": 11,
+            "BSEFO": 12,
+        }
+
+        if exchange not in exchange_code_map:
+            raise KeyError(
+                "INVALID_EXCHANGE: Exchange not in ['NSE', 'NFO', 'NSECD', 'BSECM', 'BSEFO']"
+            )
+
+        return exchange_code_map[exchange]
+
+    def get_exchange_name(self, exchange):
+        exchange_code_map = {
+            "NSE": "NSECM",
+            "NFO": "NSEFO",
+            "NSECD": "NSECD",
+            "BSECM": "BSECM",
+            "BSEFO": "BSEFO",
+        }
+
+        if exchange not in exchange_code_map:
+            raise KeyError(
+                "INVALID_EXCHANGE: Exchange not in ['NSE', 'NFO', 'NSECD', 'BSECM', 'BSEFO']"
+            )
+
+        return exchange_code_map[exchange]
+
+    def get_ltp(self, exchange=None, tradingsymbol=None):
+        exchange = self.get_exchange(exchange)
+        tradingsymbol = self.get_symbol(exchange, tradingsymbol)
+
+        api_response = self.wrapper.get_quote(
+            Instruments=[
+                {"exchangeSegment": exchange, "exchangeInstrumentID": tradingsymbol}
+            ],
+            xtsMessageCode=1512,
+            publishFormat="JSON",
+        )["result"]
+
+        ltp_json = api_response["listQuotes"][0]
+
+        ltp = json.loads(ltp_json)["LastTradedPrice"]
+
+        return ltp
+
+    def place_order(
+        self,
+        tradingsymbol=None,
+        exchange=None,
+        quantity=None,
+        order_type=None,
+        transaction_type=None,
+        tag=None,
+        product=None,
+        price=None,
+        trigger_price=0,
+    ):
+        exchange_code = self.get_exchange_code(exchange)
+        exchange_name = self.get_exchange_name(exchange)
+
+        tradingsymbol = self.get_symbol(exchange_code, tradingsymbol)
+
+        api_response = self.wrapper.place_order(
+            exchangeSegment=exchange_name,
+            exchangeInstrumentID=tradingsymbol,
+            orderType=order_type,
+            disclosedQuantity=0,
+            orderQuantity=quantity,
+            limitPrice=price,
+            timeInForce="DAY",
+            stopPrice=trigger_price,
+            orderSide=transaction_type,
+            productType=product,
+            orderUniqueIdentifier=tag,
+            clientID=self.ClientID,
+        )["result"]
+
+        return api_response["AppOrderID"]
+
+    def cancel_order(self, unique_order_id):
+        orders = self.orders()
+
+        tag = list(filter(lambda x: x["AppOrderID"] == int(unique_order_id), orders))[
+            0
+        ]["OrderUniqueIdentifier"]
+
+        api_response = self.wrapper.cancel_order(
+            appOrderID=unique_order_id,
+            clientID=self.ClientID,
+            orderUniqueIdentifier=tag,
+        )
+
+        if api_response["type"] == "error":
+            raise Exception("[XTS_ERROR]: " + api_response["description"])
+
+        return api_response["result"]["AppOrderID"]
+
+    def modify_order(
+        self,
+        order_id,
+        price=None,
+        trigger_price=None,
+        order_type=None,
+        transaction_type=None,
+        tag=None,
+        product=None,
+    ):
+        orders = self.orders()
+        order_data = list(filter(lambda x: x["AppOrderID"] == int(order_id), orders))[0]
+
+        price = price or order_data["OrderPrice"]
+        trigger_price = trigger_price or order_data["OrderStopPrice"]
+        order_type = order_type or order_data["OrderType"]
+        transaction_type = transaction_type or order_data["OrderSide"]
+        tag = tag or order_data["OrderUniqueIdentifier"]
+        product = product or order_data["ProductType"]
+
+        quantity = order_data["OrderQuantity"]
+        time_in_force = "DAY"
+        disclosed_quantity = 0
+
+        api_response = self.wrapper.modify_order(
+            appOrderID=order_id,
+            modifiedTimeInForce=time_in_force,
+            modifiedDisclosedQuantity=disclosed_quantity,
+            modifiedLimitPrice=price,
+            modifiedOrderQuantity=quantity,
+            modifiedOrderType=order_type,
+            modifiedProductType=product,
+            modifiedStopPrice=trigger_price,
+            orderUniqueIdentifier=tag,
+            clientID=self.ClientID,
+        )
+
+        if api_response["type"] == "error":
+            raise Exception("[XTS_ERROR]: " + api_response["description"])
+
+        return api_response["result"]["AppOrderID"]
+
+    def modify_price(self, order_id, price, trigger_price=None, order_type=None):
+        return self.modify_order(
+            order_id=order_id,
+            price=price,
+            trigger_price=trigger_price,
+            order_type=order_type,
+        )