quantplay 2.0.91__tar.gz → 2.0.92__tar.gz

{quantplay-2.0.91 → quantplay-2.0.92}/PKG-INFO

@@ -1,11 +1,36 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.91
+Version: 2.0.92
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 
 Author-email: 
 License: MIT
+Requires-Dist: setuptools
+Requires-Dist: path
+Requires-Dist: pyotp
+Requires-Dist: retrying
+Requires-Dist: boto3
+Requires-Dist: numpy
+Requires-Dist: websocket-client
+Requires-Dist: smartapi-python
+Requires-Dist: logzero
+Requires-Dist: selenium
+Requires-Dist: requests
+Requires-Dist: pandas
+Requires-Dist: pyarrow
+Requires-Dist: polars
+Requires-Dist: kiteconnect
+Requires-Dist: pya3
+Requires-Dist: py5paisa
+Requires-Dist: upstox-python-sdk
+Requires-Dist: undetected-chromedriver
+Requires-Dist: cachetools
+Requires-Dist: py_vollib
+Requires-Dist: python-engineio
+Requires-Dist: python-socketio
+Requires-Dist: six
+Requires-Dist: dhanhq
 
 # Quantplay Alpha playground
 

{quantplay-2.0.91 → quantplay-2.0.92}/quantplay/broker/motilal.py

@@ -285,53 +285,38 @@ class Motilal(Broker):
         Constants.logger.info(f"[GET_LTP_RESPONSE] response {response}")
         return response["data"]["ltp"] / 100.0
 
-    def add_existing_order_details(self, order_to_modify: Dict[str, str]):
-        order_id = order_to_modify["order_id"]
+    def modify_price(
+        self,
+        order_id: str,
+        price: float,
+        trigger_price: float | None = None,
+        order_type: OrderTypeType | None = None,
+    ):
         orders = self.orders()
         orders = orders.filter(pl.col("order_id") == order_id)
 
         if len(orders) != 1:
-            raise InvalidArgumentException(
-                f"Invalid modify request, order_id {order_id} not found"
+            Constants.logger.error(
+                "[ORDER_NOT_FOUND] invalid modify request for {}".format(order_id)
             )
+            return
 
         order = orders.to_dicts()[0]
         order["last_modified_time"] = str(order["last_modified_time"])
 
-        if "price" in order_to_modify:
-            order["price"] = order_to_modify["price"]
-        if (
-            "trigger_price" in order_to_modify
-            and order_to_modify["trigger_price"] is not None  # type:ignore
-        ):
-            order["trigger_price"] = order_to_modify["trigger_price"]
+        order["price"] = price
+        if trigger_price is not None:
+            order["trigger_price"] = trigger_price
 
-        if "order_type" in order_to_modify and order_to_modify["order_type"] == "SL":
+        if order["order_type"] == "SL":
             order["order_type"] = "STOPLOSS"
 
-        return order
-
-    def modify_price(
-        self,
-        order_id: str,
-        price: float,
-        trigger_price: float | None = None,
-        order_type: OrderTypeType | None = None,
-    ):
-        order_to_modify = {
-            "order_id": order_id,
-            "price": price,
-            "trigger_price": trigger_price,
-            "order_type": order_type,
-        }
-
-        self.modify_order(order_to_modify)  # type: ignore
+        print(order)
+        self.modify_order(order)  # type: ignore
 
     # TODO
     def modify_order(self, order: Any) -> str:
         order = copy.deepcopy(order)  # type:ignore
-        order = self.add_existing_order_details(order)
-
         data = {
             "uniqueorderid": order["order_id"],
             "newordertype": order["order_type"].upper(),

{quantplay-2.0.91 → quantplay-2.0.92}/quantplay/broker/noren.py

@@ -250,11 +250,6 @@ class Noren(Broker):
                 f"[PLACE_ORDER_FAILED] {exception_message}"
             )
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def ltp(self, exchange: ExchangeType, tradingsymbol: str):
         tradingsymbol = self.get_symbol(tradingsymbol, exchange)
 
@@ -380,11 +375,6 @@ class Noren(Broker):
 
         return response
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def holdings(self):
         holdings = self.invoke_noren_api(self.api.get_holdings)
         if holdings is None or len(holdings) == 0:
@@ -695,12 +685,6 @@ class Noren(Broker):
             traceback.print_exc()
             raise RetryableException("Failed to Receive Data from broker. Retrying Again")
 
-    @retry(
-        wait_exponential_multiplier=1000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def margins(self) -> MarginsResponse:
         api_margins = self.invoke_noren_api(self.api.get_limits)
 

{quantplay-2.0.91 → quantplay-2.0.92}/quantplay/broker/xts.py

@@ -12,6 +12,12 @@ from retrying import retry  # type: ignore
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.broker.xts_utils.Connect import XTSConnect
+from quantplay.broker.xts_utils.Exception import (
+    XTSDataException,
+    XTSGeneralException,
+    XTSNetworkException,
+    XTSTokenException,
+)
 from quantplay.broker.xts_utils.InteractiveSocketClient import OrderSocket_io
 from quantplay.exception.exceptions import (
     BrokerException,
@@ -76,8 +82,11 @@ class XTS(Broker):
             self.load_instrument()
 
     def set_wrapper(self, serialized_wrapper: str, serialized_md_wrapper: str):
-        self.wrapper = pickle.loads(codecs.decode(serialized_wrapper.encode(), "base64"))
-        self.md_wrapper = pickle.loads(
+        self.wrapper: XTSConnect = pickle.loads(
+            codecs.decode(serialized_wrapper.encode(), "base64")
+        )
+
+        self.md_wrapper: XTSConnect = pickle.loads(
             codecs.decode(serialized_md_wrapper.encode(), "base64")
         )
 
@@ -101,29 +110,34 @@ class XTS(Broker):
 
                 ins_type = instrument["instrument_type"]
                 name = instrument["name"]
+
                 if ins_type in ["CE", "PE"]:
                     expiry = datetime.strftime(
                         datetime.strptime(str(instrument["expiry"]), "%Y-%m-%d"),
                         "%d%b%Y",
                     ).upper()
                     strike = str(instrument["strike"]).rstrip("0")
+
                     if strike[-1] == ".":
                         strike = strike[:-1]
+
                     instrument["broker_symbol"] = f"{name} {expiry} {ins_type} {strike}"
+
                 elif ins_type == "FUT":
                     expiry = datetime.strftime(
                         datetime.strptime(str(instrument["expiry"]), "%Y-%m-%d"),
                         "%d%b%Y",
                     ).upper()
                     instrument["broker_symbol"] = f"{name} {expiry}"
+
                 else:
                     instrument["broker_symbol"] = tradingsymbol
 
-                # TODO: Types
                 self.symbol_data[f"{exchange}:{tradingsymbol}"] = instrument  # type: ignore
 
             PickleUtils.save_data(self.symbol_data, "xts_instruments")
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from server")
+
         self.initialize_broker_symbol_map()
 
     def login(self, api_key: str, api_secret: str, md_api_key: str, md_api_secret: str):
@@ -133,48 +147,53 @@ class XTS(Broker):
                 secretKey=api_secret,
                 root=self.root_url,
             )
-            xt_core_response = self.wrapper.interactive_login()
+            xt_core_response = self.invoke_xts_api(self.wrapper.interactive_login)
+
             self.md_wrapper = XTSConnect(
                 apiKey=md_api_key,
                 secretKey=md_api_secret,
                 root=self.root_url,
             )
-            md_response = self.md_wrapper.marketdata_login()
+            md_response = self.invoke_xts_api(self.md_wrapper.marketdata_login)
+
             if "type" not in xt_core_response or xt_core_response["type"] != "success":
                 print(f"api login response {xt_core_response}")
                 raise TokenException("Api key credentials are incorrect")
+
             if "type" not in md_response or md_response["type"] != "success":
                 print(f"market data login response {md_response}")
                 raise TokenException("Market data api credentials are invalid")
+
             self.ClientID = xt_core_response["result"]["userID"]
+
         except TokenException:
             raise
+
         except Exception:
             raise InvalidArgumentException("Invalid api key/secret")
 
     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():
                 user_id = self.profile()["user_id"]
                 print("Rate limit problem")
                 raise RetryableException(f"{user_id}: Request limit exceeded")
+
         if (
             "description" in response
             and "Authorization not found" in response["description"]
         ):
             raise TokenException(response["description"])
+
         if "type" in response and response["type"] == "error":
             raise Exception(f"[XTS_Error]: {response['description']}")
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def margins(self) -> MarginsResponse:
-        api_response = self.wrapper.get_balance(clientID=self.ClientID)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_balance, clientID=self.ClientID
+        )
         self.handle_exception(api_response)
 
         if not api_response:
@@ -194,14 +213,10 @@ class XTS(Broker):
             "cash": 0,
         }
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def profile(self) -> UserBrokerProfileResponse:
-        api_response = self.wrapper.get_profile(self.ClientID)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_profile, clientID=self.ClientID
+        )
         self.handle_exception(api_response)
         api_response = api_response["result"]
 
@@ -213,14 +228,10 @@ class XTS(Broker):
 
         return response
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
-        api_response = self.wrapper.get_order_book(self.ClientID)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_order_book, clientID=self.ClientID
+        )
         self.handle_exception(api_response)
 
         api_response = api_response["result"]
@@ -345,22 +356,13 @@ class XTS(Broker):
 
         return orders_df[list(self.orders_schema.keys())].cast(self.orders_schema)
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def holdings(self):
         return pl.DataFrame(schema=self.holidings_schema)
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
-        api_response = self.wrapper.get_position_daywise(self.ClientID)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_position_daywise, clientID=self.ClientID
+        )
         self.handle_exception(api_response)
 
         api_response = api_response["result"]["positionList"]
@@ -478,7 +480,9 @@ class XTS(Broker):
             }
             for x in symbols
         ]
-        api_response = self.md_wrapper.get_quote(
+
+        api_response = self.invoke_xts_api(
+            self.md_wrapper.get_quote,
             Instruments=instruments,
             xtsMessageCode=1512,
             publishFormat="JSON",
@@ -486,6 +490,7 @@ class XTS(Broker):
 
         if "type" in api_response and api_response["type"] == "error":
             raise TokenException(api_response["description"])
+
         api_response = api_response["result"]
 
         ltp_json = api_response["listQuotes"]
@@ -541,7 +546,8 @@ class XTS(Broker):
             "",  # TODO
         )
 
-        api_response = self.md_wrapper.get_quote(
+        api_response = self.invoke_xts_api(
+            self.md_wrapper.get_quote,
             Instruments=[
                 {
                     "exchangeSegment": exchange_code,
@@ -561,6 +567,7 @@ class XTS(Broker):
 
         try:
             ltp_json = api_response["listQuotes"][0]
+
         except IndexError as e:
             print(api_response, e)
             raise BrokerException("Broker Provided Invalid Response")
@@ -593,7 +600,8 @@ class XTS(Broker):
         if tag is None:
             tag = ""
 
-        api_response = self.wrapper.place_order(
+        api_response = self.invoke_xts_api(
+            self.wrapper.place_order,
             exchangeSegment=exchange_name,
             exchangeInstrumentID=exchange_token,
             orderType=xts_order_type,
@@ -626,7 +634,8 @@ class XTS(Broker):
 
         tag = order_data["tag"]
 
-        api_response = self.wrapper.cancel_order(
+        api_response = self.invoke_xts_api(
+            self.wrapper.cancel_order,
             appOrderID=int(order_id),
             clientID=order_data["user_id"],
             orderUniqueIdentifier=tag,
@@ -678,7 +687,8 @@ class XTS(Broker):
         time_in_force = "DAY"
         disclosed_quantity = 0
 
-        api_response = self.wrapper.modify_order(
+        api_response = self.invoke_xts_api(
+            self.wrapper.modify_order,
             appOrderID=int(order_id),
             modifiedTimeInForce=time_in_force,
             modifiedDisclosedQuantity=disclosed_quantity,
@@ -806,3 +816,49 @@ class XTS(Broker):
         except Exception as e:
             print(e)
             Constants.logger.error("[ORDER_UPDATE_PROCESSING_FAILED] {}".format(e))
+
+    @retry(
+        wait_exponential_multiplier=3000,
+        wait_exponential_max=10000,
+        stop_max_attempt_number=3,
+        retry_on_exception=retry_exception,
+    )
+    def invoke_xts_api(self, fn: Any, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        try:
+            response = fn(*args, **kwargs)
+
+            if "data" in response and "description" in response["data"]:
+                data = response["data"]
+
+                if "max limit" in data["description"].lower():
+                    user_id = self.profile()["user_id"]
+                    print("Rate limit problem")
+                    raise RetryableException(f"{user_id}: Request limit exceeded")
+
+            if (
+                "description" in response
+                and "Authorization not found" in response["description"]
+            ):
+                raise TokenException(response["description"])
+
+            if "type" in response and response["type"] == "error":
+                raise Exception(f"[XTS_Error]: {response['description']}")
+
+            return response
+
+        except XTSTokenException as e:
+            raise TokenException(str(e))
+
+        except (TokenException, RetryableException):
+            raise
+
+        except (
+            XTSGeneralException,
+            XTSDataException,
+            XTSNetworkException,
+        ) as e:
+            raise BrokerException(str(e))
+
+        except Exception:
+            traceback.print_exc()
+            raise