quantplay 2.0.25__tar.gz → 2.0.27__tar.gz

{quantplay-2.0.25 → quantplay-2.0.27}/PKG-INFO

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

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/aliceblue.py

@@ -213,8 +213,10 @@ class Aliceblue(Broker):
             exception_message = f"Order placement failed [{str(e)}]"
             raise QuantplayOrderPlacementException(exception_message)
 
-    def get_ltp(self, exchange, tradingsymbol: str):
-        inst = self.alice.get_instrument_by_symbol(exchange, tradingsymbol)
+    def ltp(self, exchange, tradingsymbol: str):
+        inst = self.invoke_aliceblue_api(
+            self.alice.get_instrument_by_symbol, exchange=exchange, symbol=tradingsymbol
+        )
         info = self.invoke_aliceblue_api(self.alice.get_scrip_info, instrument=inst)
 
         return float(info["LTP"])
@@ -327,7 +329,7 @@ class Aliceblue(Broker):
         holdings_df = holdings_df.with_columns(
             pl.struct(["exchange", "tradingsymbol"])
             .map_elements(
-                lambda x: int(self.get_ltp(x["exchange"], x["tradingsymbol"])),
+                lambda x: int(self.ltp(x["exchange"], x["tradingsymbol"])),
                 return_dtype=pl.Float64,
             )
             .alias("price")
@@ -453,6 +455,8 @@ class Aliceblue(Broker):
             orders_df = orders_df.join(
                 positions.select(["tradingsymbol", "ltp"]), on="tradingsymbol", how="left"
             )
+        else:
+            orders_df = orders_df.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
 
         if "rorgqty" in orders_df.columns:
             orders_df = orders_df.with_columns(
@@ -547,10 +551,6 @@ class Aliceblue(Broker):
     def margins(self):
         margins = self.invoke_aliceblue_api(self.alice.get_balance)
 
-        if "emsg" in margins and "expired" in margins["emsg"].lower():
-            raise TokenException("Session expired")
-        if "stat" in margins and "not_ok" in margins["stat"].lower():
-            raise TokenException(f"Aliceblue broker error: {margins['emsg']}")
         margins = [a for a in margins if a["segment"] == "ALL"][0]
 
         response = {
@@ -570,6 +570,11 @@ class Aliceblue(Broker):
     def invoke_aliceblue_api(self, fn: Callable, *args, **kwargs) -> Any:
         try:
             response = fn(*args, **kwargs)
+
+            if "emsg" in response and "expired" in response["emsg"].lower():
+                raise TokenException("Session expired")
+            if "stat" in response and response["stat"].lower() == "not_ok":
+                raise InvalidArgumentException(response["emsg"])
             if response is None:
                 raise InvalidArgumentException(
                     "Invalid data response. Aliceblue sent incorrect data, Please check."
@@ -577,8 +582,8 @@ class Aliceblue(Broker):
 
             return response
 
-        except TokenException:
-            raise QuantplayTokenException("Token Expired")
+        except (TokenException, InvalidArgumentException):
+            raise
 
         except Exception:
             traceback.print_exc()

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/angelone.py

@@ -23,7 +23,6 @@ from quantplay.exception.exceptions import (
     TokenException,
     retry_exception,
 )
-from quantplay.exception.exceptions import TokenException as QuantplayTokenException
 from quantplay.model.broker import ModifyOrderRequest, UserBrokerProfileResponse
 from quantplay.model.order_event import OrderUpdateEvent
 from quantplay.utils.constant import Constants, OrderType
@@ -162,12 +161,7 @@ class AngelOne(Broker):
             "Product {} not supported for trading".format(product)
         )
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
-    def get_ltp(self, exchange, tradingsymbol: str) -> float:
+    def ltp(self, exchange, tradingsymbol: str) -> float:
         if tradingsymbol in MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP:
             tradingsymbol = MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP[
                 tradingsymbol
@@ -185,11 +179,6 @@ class AngelOne(Broker):
             symboltoken=symboltoken,
         )
 
-        if "status" in response and response["status"] is False:
-            raise InvalidArgumentException(
-                "Failed to fetch ltp broker error {}".format(response)
-            )
-
         return response["data"]["ltp"]
 
     def place_order(
@@ -310,18 +299,8 @@ class AngelOne(Broker):
     def cancel_order(self, order_id, variety="NORMAL"):
         self.wrapper.cancelOrder(order_id=order_id, variety=variety)
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=15000,
-        stop_max_attempt_number=5,
-        retry_on_exception=retry_exception,
-    )
     def holdings(self):
-        try:
-            holdings = self.invoke_angelone_api(self.wrapper.holding)
-        except Exception:
-            raise RetryableException("Access Denied retrying")
-        self.handle_exception(holdings)
+        holdings = self.invoke_angelone_api(self.wrapper.holding)
 
         if holdings["data"] is None or len(holdings["data"]) == 0:
             return pl.DataFrame(schema=self.holidings_schema)
@@ -350,15 +329,11 @@ class AngelOne(Broker):
     @retry(
         wait_exponential_multiplier=3000,
         wait_exponential_max=15000,
-        stop_max_attempt_number=5,
+        stop_max_attempt_number=2,
         retry_on_exception=retry_exception,
     )
     def positions(self, drop_cnc: bool = True):
-        try:
-            positions = self.invoke_angelone_api(self.wrapper.position)
-        except Exception:
-            raise RetryableException("Access Denied retrying")
-        self.handle_exception(positions)
+        positions = self.invoke_angelone_api(self.wrapper.position)
 
         if positions["data"] is None:
             return pl.DataFrame(schema=self.positions_schema)
@@ -427,18 +402,8 @@ class AngelOne(Broker):
             self.positions_schema
         )
 
-    @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:
-        try:
-            order_book = self.invoke_angelone_api(self.wrapper.orderBook)
-        except Exception:
-            raise RetryableException("Access Denied retrying")
-        self.handle_exception(order_book)
+        order_book = self.invoke_angelone_api(self.wrapper.orderBook)
 
         if order_book["data"]:
             orders_df = pl.DataFrame(order_book["data"])
@@ -534,21 +499,10 @@ class AngelOne(Broker):
                 traceback.print_exc()
                 raise ServiceException("Unknown error while fetching order book [{}]")
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def profile(self):
-        try:
-            profile_data = self.invoke_angelone_api(
-                self.wrapper.getProfile, refreshToken=self.refresh_token
-            )
-        except Exception:
-            raise RetryableException("Access Denied retrying")
-
-        self.handle_exception(profile_data)
+        profile_data = self.invoke_angelone_api(
+            self.wrapper.getProfile, refreshToken=self.refresh_token
+        )
 
         profile_data = profile_data["data"]
         response: UserBrokerProfileResponse = {
@@ -559,21 +513,14 @@ class AngelOne(Broker):
 
         return response
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def margins(self):
         api_margins = self.invoke_angelone_api(self.wrapper.rmsLimit)
-        self.handle_exception(api_margins)
 
         if "data" in api_margins and api_margins["data"] is None:
             if "errorcode" in api_margins and api_margins["errorcode"] == "AB1004":
                 raise TokenException("Angelone server not not responding")
 
-            return {"margin_used": 0, "margin_available": 0, "total_balance": 0}
+            return {"margin_used": 0.0, "margin_available": 0.0, "total_balance": 0.0}
 
         api_margins = api_margins["data"]
 
@@ -610,19 +557,25 @@ class AngelOne(Broker):
 
         return response
 
+    @retry(
+        wait_exponential_multiplier=3000,
+        wait_exponential_max=10000,
+        stop_max_attempt_number=3,
+        retry_on_exception=retry_exception,
+    )
     def invoke_angelone_api(self, fn: Callable, *args, **kwargs) -> Dict:
         try:
             response = fn(*args, **kwargs)
+            if "errorCode" in response and response["errorCode"] == "AG8001":
+                raise TokenException(f"{self.user_id}: Invalid Token")
             if isinstance(response, bytes):
                 raise InvalidArgumentException(
                     "Invalid data response. AngelOne sent incorrect data, Please check."
                 )
 
             return response
-
-        except TokenException:
-            raise QuantplayTokenException("Token Expired")
-
+        except (TokenException, InvalidArgumentException):
+            raise
         except Exception:
             traceback.print_exc()
             raise RetryableException("Failed to fetch user profile")

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/five_paisa.py

@@ -134,7 +134,7 @@ class FivePaisa(Broker):
         stop_max_attempt_number=3,
         retry_on_exception=retry_exception,
     )
-    def get_ltp(self, exchange, tradingsymbol: str) -> float:
+    def ltp(self, exchange, tradingsymbol: str) -> float:
         tradingsymbol = self.get_symbol(tradingsymbol, exchange)
         exchange_name = self.get_exchange(exchange)
         exchange_type = self.get_exchange_type(exchange)
@@ -413,6 +413,8 @@ class FivePaisa(Broker):
                 .then(-pl.col("pnl"))
                 .otherwise(pl.col("pnl"))
             )
+        else:
+            orders = orders.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
 
         return orders
 

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/generics/broker.py

@@ -456,7 +456,7 @@ class Broker:
 
     def live_data(self, exchange, tradingsymbol):
         return {
-            "ltp": self.get_ltp(exchange, tradingsymbol),
+            "ltp": self.ltp(exchange, tradingsymbol),
             "upper_circuit": None,
             "lower_circuit": None,
         }
@@ -606,7 +606,7 @@ class Broker:
             exchange = stoploss_order["exchange"]
             tradingsymbol = stoploss_order["tradingsymbol"]
 
-            ltp = self.get_ltp(exchange, tradingsymbol)
+            ltp = self.ltp(exchange, tradingsymbol)
             stoploss_order["order_type"] = "LIMIT"
             stoploss_order["price"] = self.round_to_tick(ltp)
             stoploss_order["trigger_price"] = None
@@ -713,7 +713,7 @@ class Broker:
         positions = positions.with_columns(
             pl.struct(["exchange", "tradingsymbol"])
             .map_elements(
-                lambda x: int(self.get_ltp(x["exchange"], x["tradingsymbol"])),
+                lambda x: int(self.ltp(x["exchange"], x["tradingsymbol"])),
                 return_dtype=pl.Float64,
             )
             .alias("price")
@@ -895,7 +895,7 @@ class Broker:
             elif "SENSEX" in symbol and exchange == "BFO":
                 return self.underlying_config("SENSEX")["max_lots"]
             elif exchange == "NSE":
-                max_qty = int(500000 / self.get_ltp(exchange, symbol))
+                max_qty = int(500000 / self.ltp(exchange, symbol))
                 if max_qty == 0:
                     return 1
                 return max_qty
@@ -995,9 +995,7 @@ class Broker:
         all_symbols = list(orders.exchange_symbol.unique())
         symbol_ltp = {}
         for exchange_symbol in all_symbols:
-            ltp = self.get_ltp(
-                exchange_symbol.split(":")[0], exchange_symbol.split(":")[1]
-            )
+            ltp = self.ltp(exchange_symbol.split(":")[0], exchange_symbol.split(":")[1])
             symbol_ltp[exchange_symbol] = ltp
         orders.loc[:, "ltp"] = orders["exchange_symbol"].map(symbol_ltp)
 
@@ -1130,7 +1128,7 @@ class Broker:
                 else:
                     modification_count[order_id] += 1
 
-                ltp = self.get_ltp(order["exchange"], order["tradingsymbol"])
+                ltp = self.ltp(order["exchange"], order["tradingsymbol"])
 
                 market_protection = 0.02
                 if modification_count[order_id] > 5:
@@ -1237,7 +1235,7 @@ class Broker:
         """
         raise NotImplementedError
 
-    def get_ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
+    def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
         """_summary_
 
         Args:
@@ -1284,3 +1282,12 @@ class Broker:
             UserBrokerProfile: contains exchange user_id full_name and email
         """
         raise NotImplementedError
+
+    def margins(self) -> Dict[str, float]:
+        """Returns User Margin Summary
+
+        Raises:
+            NotImplementedError: if Function Not Implemented by Sub class
+
+        """
+        raise NotImplementedError

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/motilal.py

@@ -19,6 +19,7 @@ import binascii
 from quantplay.utils.pickle_utils import InstrumentData
 from quantplay.exception.exceptions import (
     QuantplayOrderPlacementException,
+    TokenException,
     retry_exception,
     RetryableException,
 )
@@ -88,7 +89,7 @@ class Motilal(Broker):
         self.verify_otp_url = (
             "https://{}openapi.motilaloswal.com/rest/login/v3/verifyotp".format(uat)
         )
-        self.ltp_utl = (
+        self.ltp_url = (
             "https://{}openapi.motilaloswal.com/rest/report/v1/getltpdata".format(uat)
         )
         self.place_order_url = (
@@ -133,8 +134,7 @@ class Motilal(Broker):
             else:
                 raise Exception("Missing Arguments")
 
-            profile = self.profile()
-            self.user_id = profile["user_id"]
+            self.user_id = self.headers["vendorinfo"]
         except binascii.Error:
             raise InvalidArgumentException("Invalid TOTP key provided")
         except InvalidArgumentException:
@@ -263,12 +263,7 @@ class Motilal(Broker):
         Constants.logger.info(response)
         return response
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
-    def get_ltp(self, exchange, tradingsymbol: str) -> float:
+    def ltp(self, exchange, tradingsymbol: str) -> float:
         tradingsymbol = self.get_symbol(tradingsymbol)
         token = self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["token"]
         exchange = self.get_exchange(exchange)
@@ -279,9 +274,7 @@ class Motilal(Broker):
         }
 
         Constants.logger.info("[GET_LTP_REQUEST] response {}".format(data))
-        response = requests.post(
-            self.ltp_utl, headers=self.headers, data=json.dumps(data)
-        )
+        response = self.__post_request(self.ltp_url, json.dumps(data))
         Constants.logger.info("[GET_LTP_RESPONSE] response {}".format(response.json()))
         return response.json()["data"]["ltp"] / 100.0
 
@@ -383,36 +376,15 @@ class Motilal(Broker):
             )
             Constants.logger.error(exception_message)
 
-    def get_profile(self):
-        response = requests.post(
-            self.get_profile_url,
-            headers=self.headers,
-            data=json.dumps({"Clientcode": self.headers["vendorinfo"]}),
-        ).json()
-        if response["status"] == "ERROR":
-            raise Exception(response["message"])
-
-        return response["data"]
-
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def margins(self):
-        response = requests.post(
-            self.margin_summary_url,
-            headers=self.headers,
-            data=json.dumps({"Clientcode": self.headers["vendorinfo"]}),
-        ).json()
-        if response["status"] == "ERROR":
-            raise Exception(response["message"])
+        response = self.__post_request(self.margin_summary_url, {})
         margin_summary = response["data"]
 
-        margins = {"margin_used": 0, "margin_available": 0}
+        margins = {"margin_used": 0.0, "margin_available": 0.0}
         for margin_particular in margin_summary:
             if margin_particular["srno"] in [103]:
                 margins["margin_available"] += margin_particular["amount"]
+
             if margin_particular["srno"] in [301, 321, 340, 360]:
                 margins["margin_used"] += margin_particular["amount"]
 
@@ -554,14 +526,35 @@ class Motilal(Broker):
 
         return response
 
-    def profile(self) -> UserBrokerProfileResponse:
+    @retry(
+        wait_exponential_multiplier=3000,
+        wait_exponential_max=10000,
+        stop_max_attempt_number=3,
+        retry_on_exception=retry_exception,
+    )
+    def __post_request(self, url, data):
         api_response = requests.post(
-            self.get_profile_url,
+            url,
             headers=self.headers,
             data=json.dumps({"Clientcode": self.headers["vendorinfo"]}),
         ).json()
-        if api_response["status"] == "ERROR":
-            raise Exception(api_response["message"])
+
+        if api_response["status"] == "ERROR" and api_response["errorcode"] in [
+            "MO8001",
+            "MO8002",
+            "MO8003",
+            "MO8050",
+            "MO8051",
+            "MO8052",
+        ]:
+            raise TokenException("Motilal token expired")
+        elif api_response["status"] == "ERROR":
+            raise RetryableException(api_response["message"])
+
+        return api_response
+
+    def profile(self) -> UserBrokerProfileResponse:
+        api_response = self.__post_request(self.get_profile_url, {})
 
         api_response = api_response["data"]
         response: UserBrokerProfileResponse = {
@@ -578,7 +571,7 @@ class Motilal(Broker):
         stop_max_attempt_number=3,
     )
     def holdings(self):
-        response = (requests.post(self.holdings_url, headers=self.headers)).json()
+        response = self.__post_request(self.holdings_url, {})
         if response["status"] == "ERROR":
             Constants.logger.info(
                 "Error while fetching order book [{}]".format(response["message"])
@@ -605,7 +598,7 @@ class Motilal(Broker):
         holdings_df = holdings_df.with_columns(
             pl.struct(["exchange", "tradingsymbol"])
             .map_elements(
-                lambda x: int(self.get_ltp(x["exchange"], x["tradingsymbol"])),
+                lambda x: int(self.ltp(x["exchange"], x["tradingsymbol"])),
                 return_dtype=pl.Float64,
             )
             .alias("price")
@@ -624,13 +617,8 @@ class Motilal(Broker):
 
         return holdings_df[list(self.holidings_schema.keys())].cast(self.holidings_schema)
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
-        response = (requests.post(self.positions_url, headers=self.headers)).json()
+        response = self.__post_request(self.positions_url, {})
         if response["status"] == "ERROR":
             Constants.logger.info(
                 "Error while fetching positions [{}]".format(response["message"])
@@ -699,7 +687,7 @@ class Motilal(Broker):
         )
 
     def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
-        response = (requests.post(self.order_book_url, headers=self.headers)).json()
+        response = self.__post_request(self.order_book_url, {})
         if response["status"] == "ERROR":
             Constants.logger.info(
                 "Error while fetching order book [{}]".format(response["message"])
@@ -742,6 +730,8 @@ class Motilal(Broker):
             orders_df = orders_df.join(
                 positions.select(["tradingsymbol", "ltp"]), on="tradingsymbol", how="left"
             )
+        else:
+            orders_df = orders_df.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
 
         orders_df = orders_df.with_columns(
             pl.when(pl.col("product") == "VALUEPLUS")

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/noren.py

@@ -75,6 +75,8 @@ class Noren(Broker):
     def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
         if symbol not in self.quantplay_symbol_map:
             return symbol
+        if exchange == "NSE" and "-EQ" not in symbol:
+            return f"{symbol}-EQ"
 
         return self.quantplay_symbol_map[symbol]
 
@@ -246,8 +248,8 @@ class Noren(Broker):
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
     )
-    def get_ltp(self, exchange, tradingsymbol):
-        tradingsymbol = self.get_symbol(tradingsymbol)
+    def ltp(self, exchange, tradingsymbol):
+        tradingsymbol = self.get_symbol(tradingsymbol, exchange)
 
         token = self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["token"]
         quote = self.api.get_quotes(exchange, str(token))
@@ -387,7 +389,7 @@ class Noren(Broker):
         holdings_df = holdings_df.with_columns(
             pl.struct(["exchange", "tradingsymbol"])
             .map_elements(
-                lambda x: int(self.get_ltp(x["exchange"], x["tradingsymbol"])),
+                lambda x: int(self.ltp(x["exchange"], x["tradingsymbol"])),
                 return_dtype=pl.Float64,
             )
             .alias("price")
@@ -523,6 +525,8 @@ class Noren(Broker):
             orders_df = orders_df.join(
                 positions.select(["tradingsymbol", "ltp"]), on="tradingsymbol", how="left"
             )
+        else:
+            orders_df = orders_df.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
 
         orders_df = orders_df.with_columns(pl.lit(None).alias("variety"))
 

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/upstox.py

@@ -126,7 +126,7 @@ class Upstox(Broker):
         stop_max_attempt_number=3,
         retry_on_exception=retry_exception,
     )
-    def get_ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
+    def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
         api_instance = upstox_client.MarketQuoteApi(self.api_client)
 
         ltp = 0
@@ -315,7 +315,7 @@ class Upstox(Broker):
         holdings_df = holdings_df.with_columns(
             pl.struct(["exchange", "tradingsymbol"])
             .map_elements(
-                lambda x: int(self.get_ltp(x["exchange"], x["tradingsymbol"])),
+                lambda x: int(self.ltp(x["exchange"], x["tradingsymbol"])),
                 return_dtype=pl.Float64,
             )
             .alias("price")
@@ -465,6 +465,8 @@ class Upstox(Broker):
             orders_df = orders_df.join(
                 positions.select(["tradingsymbol", "ltp"]), on="tradingsymbol", how="left"
             )
+        else:
+            orders_df = orders_df.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
         orders_df = orders_df.rename({"placed_by": "user_id"})
 
         orders_df = orders_df.with_columns(

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/xts.py

@@ -275,6 +275,8 @@ class XTS(Broker):
             orders_df = orders_df.join(
                 positions.select(["tradingsymbol", "ltp"]), on="tradingsymbol", how="left"
             )
+        else:
+            orders_df = orders_df.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
 
         orders_df = orders_df.with_columns(
             pl.col("filled_quantity").cast(pl.Int64).alias("filled_quantity"),
@@ -538,7 +540,7 @@ class XTS(Broker):
 
         return exchange_code_map[exchange]
 
-    def get_ltp(self, exchange=None, tradingsymbol=None) -> float:
+    def ltp(self, exchange=None, tradingsymbol=None) -> float:
         exchange_code = self.get_exchange_code(exchange)
         exchange_token = self.symbol_data[f"{exchange}:{tradingsymbol}"]["exchange_token"]
 

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay/broker/zerodha.py

@@ -132,8 +132,9 @@ class Zerodha(Broker):
         wait_exponential_multiplier=3000,
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
+        retry_on_exception=retry_exception,
     )
-    def get_ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
+    def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
         try:
             key = "{}:".format(exchange) + tradingsymbol
             response = self.wrapper.ltp([key])
@@ -149,11 +150,13 @@ class Zerodha(Broker):
                 )
 
             return api_response[key]["last_price"]
+        except TokenException:
+            raise QuantplayTokenException("Zerodha token expired")
         except Exception as e:
             exception_message = "GetLtp call failed for [{}] with error [{}]".format(
                 tradingsymbol, str(e)
             )
-            raise InvalidArgumentException(exception_message)
+            raise RetryableException(exception_message)
 
     @retry(
         wait_exponential_multiplier=3000,
@@ -211,7 +214,7 @@ class Zerodha(Broker):
         exchange = order["exchange"]
         tradingsymbol = order["tradingsymbol"]
 
-        return self.get_ltp(exchange, tradingsymbol)
+        return self.ltp(exchange, tradingsymbol)
 
     @retry(
         wait_exponential_multiplier=3000,
@@ -492,6 +495,8 @@ class Zerodha(Broker):
             orders_df = orders_df.join(
                 positions.select(["tradingsymbol", "ltp"]), on="tradingsymbol", how="left"
             )
+        else:
+            orders_df = orders_df.with_columns(pl.lit(None).cast(pl.Float64).alias("ltp"))
 
         orders_df = orders_df.with_columns(
             (

{quantplay-2.0.25 → quantplay-2.0.27}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.0.25 → quantplay-2.0.27}/setup.py

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