quantplay 1.2.45__tar.gz → 1.2.46__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 1.2.45
+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,
+        )

{quantplay-1.2.45 → quantplay-1.2.46}/quantplay/broker/xts_utils/Connect.py

@@ -136,7 +136,8 @@ class XTSConnect(XTSCommon):
         apiKey,
         secretKey,
         source,
-        root=None,
+        root_interactive,
+        root_market,
         debug=False,
         timeout=None,
         pool=None,
@@ -165,7 +166,8 @@ class XTSConnect(XTSCommon):
         self.secretKey = secretKey
         self.source = source
         self.disable_ssl = disable_ssl
-        self.root = root or self._default_root_uri
+        self.root_interactive = root_interactive
+        self.root_market = root_market
         self.timeout = timeout or self._default_timeout
 
         super().__init__()
@@ -256,6 +258,7 @@ class XTSConnect(XTSCommon):
             response = self._post("order.place", json.dumps(params))
             return response
         except Exception as e:
+            print(e)
             return response["description"]
 
     def place_bracketorder(
@@ -797,8 +800,13 @@ class XTSConnect(XTSCommon):
         params = parameters if parameters else {}
 
         # Form a restful URL
+        if route.split(".")[0] == "market":
+            root = self.root_market
+        else:
+            root = self.root_interactive
+
         uri = self._routes[route].format(params)
-        url = urljoin(self.root, uri)
+        url = urljoin(root, uri)
         headers = {}
 
         if self.token:

{quantplay-1.2.45 → quantplay-1.2.46}/quantplay.egg-info/PKG-INFO

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

{quantplay-1.2.45 → quantplay-1.2.46}/quantplay.egg-info/SOURCES.txt

@@ -18,10 +18,12 @@ quantplay/broker/__init__.py
 quantplay/broker/angelone.py
 quantplay/broker/broker_client.py
 quantplay/broker/client.py
+quantplay/broker/iifl_xts.py
 quantplay/broker/kite_utils.py
 quantplay/broker/motilal.py
 quantplay/broker/shoonya.py
 quantplay/broker/symphony.py
+quantplay/broker/xts.py
 quantplay/broker/zerodha.py
 quantplay/broker/finvasia_utils/__init__.py
 quantplay/broker/finvasia_utils/shoonya.py

{quantplay-1.2.45 → quantplay-1.2.46}/setup.py

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

quantplay-1.2.45/quantplay/broker/symphony.py

@@ -1,125 +0,0 @@
-import traceback
-import requests
-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 Symphony(Broker):
-    source = "WebAPI"
-
-    symphony_secret_key = "symphony_secret_key"
-    symphony_app_key = "symphony_app_secret"
-
-    @timeit(MetricName="Symphony:__init__")
-    def __init__(self, headers=None, api_secret=None, api_key=None):
-        super(Symphony, self).__init__()
-
-        try:
-            self.wrapper = XTSConnect(
-                apiKey=api_key, secretKey=api_secret, source=self.source
-            )
-            self.login()
-
-        except Exception as e:
-            print(traceback.print_exc())
-            raise e
-
-    def login(self):
-        response = self.wrapper.interactive_login()
-        self.wrapper.marketdata_login()
-
-        self.ClientID = response["result"]["clientCodes"][0]
-
-    def account_summary(self):
-        api_response = self.wrapper.get_balance(self.ClientID)
-
-        if not api_response:
-            raise Exception(
-                "[SYMPHONY_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):
-        api_response = self.wrapper.get_order_book(self.ClientID)["result"]
-
-        return api_response
-
-    def positions(self):
-        api_response = self.wrapper.get_position_daywise(self.ClientID)["result"]
-
-        return api_response
-
-    def get_symbol(self, exchange, symbol, series="EQ"):
-        # TODO: Add Futures and Options
-
-        if series not in ["FUTIDX", "EQ"]:
-            raise KeyError("INVALID_SERIES: Series not in ['FUTIDX', 'EQ']")
-
-        if series == "EQ":
-            response = self.wrapper.get_equity_symbol(
-                exchangeSegment=exchange, series=series, symbol=symbol
-            )
-
-            if response["type"] == "error":
-                raise Exception("[SYMPHONY_ERROR]: " + response["description"])
-
-            return response["result"][0]["ExchangeInstrumentID"]
-
-    def get_exchange(self, exchange):
-        # TODO: Confirm Formats
-        exchange_code_map = {
-            "NSECM": 1,
-            "NSEFO": 2,
-            "NSECD": 3,
-            "BSECM": 11,
-            "BSEFO": 12,
-        }
-
-        if exchange not in exchange_code_map:
-            raise KeyError(
-                "INVALID_EXCHANGE: Exchange not in ['NSECM', 'NSEFO', '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