quantplay 2.0.95__tar.gz → 2.0.97__tar.gz

{quantplay-2.0.95 → quantplay-2.0.97}/PKG-INFO

@@ -1,11 +1,36 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.95
+Version: 2.0.97
 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.95 → quantplay-2.0.97}/quantplay/broker/aliceblue.py

@@ -250,6 +250,7 @@ class Aliceblue(Broker):
                 exchange=exchange,
                 symbol=tradingsymbol,
             )
+
         except Exception:
             inst = self.invoke_aliceblue_api(
                 self.alice.get_instrument_by_symbol,

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/angelone.py

@@ -47,12 +47,6 @@ class AngelOne(Broker):
     order_sl = "STOPLOSS_LIMIT"
     order_slm = "STOPLOSS_MARKET"
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=5,
-        retry_on_exception=retry_exception,
-    )
     def __init__(
         self,
         order_updates: Queue[OrderUpdateEvent] | None = None,
@@ -107,7 +101,7 @@ class AngelOne(Broker):
             raise InvalidArgumentException("Invalid TOTP key provided")
 
         except Exception as e:
-            print(e)
+            traceback.print_exc()
             raise RetryableException(str(e))
 
         self.user_id = user_id
@@ -250,11 +244,6 @@ class AngelOne(Broker):
             return "NORMAL"
         return variety
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def modify_order(self, order: ModifyOrderRequest) -> str:
         data = copy.deepcopy(order)
         order_id = str(data["order_id"])
@@ -337,12 +326,6 @@ class AngelOne(Broker):
 
         return holdings
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=15000,
-        stop_max_attempt_number=2,
-        retry_on_exception=retry_exception,
-    )
     def positions(self, drop_cnc: bool = True):
         positions = self.invoke_angelone_api(self.wrapper.position)
 

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/auto_login/aliceblue.py

@@ -87,15 +87,19 @@ class AliceblueLogin:
 
         except binascii.Error:
             raise InvalidArgumentException("Invalid TOTP key provided")
+
         except InvalidArgumentException:
             raise
+
         except NoSuchElementException:
             raise BrokerException(
                 "Login to Aliceblue failed. Please log in manually to generate a new token"
             )
+
         except WebDriverException:
             traceback.print_exc()
             raise RetryableException("Selenium setup need to be fixed")
+
         except Exception as e:
             traceback.print_exc()
             raise RetryableException(str(e))

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/dhan.py

@@ -69,13 +69,7 @@ class Dhan(Broker):
     def get_username(self):
         return self.username
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def modify_order(self, order: Any) -> str:
-        # TODO
         order_id = order["order_id"]
         existing_order: Dict[str, Any] = self.invoke_dhan_api(
             self.dhan.get_order_by_id,  # type: ignore

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/five_paisa.py

@@ -136,12 +136,6 @@ class FivePaisa(Broker):
         tradingsymbol = self.get_symbol(tradingsymbol, exchange)
         return int(self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["lot_size"])
 
-    @retry(
-        wait_exponential_multiplier=1000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def profile(self):
         response: UserBrokerProfileResponse = {
             "user_id": self.client.client_code,

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/ft_utils/flattrade_utils.py

@@ -105,10 +105,13 @@ class FlatTradeUtils:
 
         except binascii.Error:
             raise InvalidArgumentException("Invalid TOTP key provided")
+
         except (InvalidArgumentException, TokenException) as e:
             raise e
+
         except WebDriverException:
             raise WrongLibrarySetup("Selenium setup need to be fixed")
+
         except Exception as e:
             traceback.print_exc()
             raise RetryableException(str(e))

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/generics/broker.py

@@ -217,12 +217,12 @@ class Broker(ABC):
         return pd.read_csv(f"/tmp/{file_name}.csv")  # type: ignore
 
     @cached(cache=TTLCache(maxsize=1, ttl=2))  # type: ignore
-    def cached_orders(self) -> pl.DataFrame:
-        return self.orders()
+    def cached_orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
+        return self.orders(tag, add_ltp)
 
     @cached(cache=TTLCache(maxsize=1, ttl=2))  # type: ignore
-    def cached_positions(self) -> pl.DataFrame:
-        return self.positions()
+    def cached_positions(self, drop_cnc: bool = True) -> pl.DataFrame:
+        return self.positions(drop_cnc)
 
     def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
         return symbol
@@ -300,11 +300,11 @@ class Broker(ABC):
                     "lot_size"
                 ]
             )
-        except Exception as e:
+        except Exception:
             logger.error(
                 f"[GET_LOT_SIZE] unable to get lot size for {broker_exchange} {tradingsymbol}"
             )
-            raise e
+            raise
 
     def filter_orders(
         self, orders: pl.DataFrame, tag: str | None = None, status: str | None = None

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/motilal.py

@@ -327,7 +327,6 @@ class Motilal(Broker):
 
         self.modify_order(order_to_modify)  # type: ignore
 
-    # TODO
     def modify_order(self, order: Any) -> str:
         order = copy.deepcopy(order)  # type:ignore
         order = self.add_existing_order_details(order)
@@ -517,11 +516,6 @@ class Motilal(Broker):
 
         return response
 
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-    )
     def holdings(self):
         response = self.__post_request(self.holdings_url, {})
         if response["status"] == "ERROR":

{quantplay-2.0.95 → quantplay-2.0.97}/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.95 → quantplay-2.0.97}/quantplay/broker/shoonya.py

@@ -56,8 +56,10 @@ class FinvAsia(Noren):
 
         except TokenException:
             raise
+
         except binascii.Error:
             raise TokenException("Invalid TOTP key provided")
+
         except Exception as e:
             raise RetryableException(str(e))
 

{quantplay-2.0.95 → quantplay-2.0.97}/quantplay/broker/uplink/uplink_utils.py

@@ -108,12 +108,16 @@ class UplinkUtils:
             driver.close()
 
             return request_token
+
         except binascii.Error:
             raise InvalidArgumentException("Invalid TOTP key provided")
+
         except InvalidArgumentException:
             raise
+
         except WebDriverException:
             raise RetryableException("Selenium setup need to be fixed")
+
         except Exception as e:
             traceback.print_exc()
             raise RetryableException(str(e))

{quantplay-2.0.95 → quantplay-2.0.97}/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,
@@ -66,7 +72,7 @@ class XTS(Broker):
             ):
                 self.login(api_key, api_secret, md_api_key, md_api_secret)
             else:
-                raise Exception("Missing Arguments")
+                raise InvalidArgumentException("Missing Arguments")
 
         except Exception as e:
             traceback.print_exc()
@@ -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")
         )
 
@@ -85,6 +94,7 @@ class XTS(Broker):
         try:
             self.symbol_data = InstrumentData.get_instance().load_data("xts_instruments")  # type: ignore
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
+
         except Exception:
             instruments = pd.read_csv(  # type: ignore
                 "https://quantplay-public-data.s3.ap-south-1.amazonaws.com/symbol_data/instruments.csv"
@@ -101,29 +111,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,49 +148,35 @@ 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)
-        self.handle_exception(api_response)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_balance, clientID=self.ClientID
+        )
 
         if not api_response:
             return {
@@ -184,9 +185,11 @@ class XTS(Broker):
                 "total_balance": 0,
                 "cash": 0,
             }
+
         api_response = api_response["result"]["BalanceList"][0]["limitObject"]
         margin_used = api_response["RMSSubLimits"]["marginUtilized"]
         margin_available = api_response["RMSSubLimits"]["netMarginAvailable"]
+
         return {
             "margin_used": margin_used,
             "margin_available": margin_available,
@@ -194,15 +197,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)
-        self.handle_exception(api_response)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_profile, clientID=self.ClientID
+        )
         api_response = api_response["result"]
 
         response: UserBrokerProfileResponse = {
@@ -213,15 +211,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)
-        self.handle_exception(api_response)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_order_book, clientID=self.ClientID
+        )
 
         api_response = api_response["result"]
         if api_response is None or len(api_response) == 0:
@@ -345,23 +338,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)
-        self.handle_exception(api_response)
+        api_response = self.invoke_xts_api(
+            self.wrapper.get_position_daywise, clientID=self.ClientID
+        )
 
         api_response = api_response["result"]["positionList"]
         positions_df = pl.DataFrame(api_response)
@@ -478,7 +461,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 +471,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"]
@@ -537,11 +523,11 @@ class XTS(Broker):
     def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
         exchange_code = self.get_exchange_code(exchange)
         exchange_token = self.symbol_data[f"{exchange}:{tradingsymbol}"].get(
-            "exchange_token",
-            "",  # TODO
+            "exchange_token", ""
         )
 
-        api_response = self.md_wrapper.get_quote(
+        api_response = self.invoke_xts_api(
+            self.md_wrapper.get_quote,
             Instruments=[
                 {
                     "exchangeSegment": exchange_code,
@@ -561,8 +547,9 @@ class XTS(Broker):
 
         try:
             ltp_json = api_response["listQuotes"][0]
-        except IndexError as e:
-            print(api_response, e)
+
+        except IndexError:
+            traceback.print_exc()
             raise BrokerException("Broker Provided Invalid Response")
 
         ltp = json.loads(ltp_json)["LastTradedPrice"]
@@ -626,7 +613,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 +666,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,
@@ -804,5 +793,52 @@ class XTS(Broker):
                 self.order_updates.put(new_ord)
 
         except Exception as e:
-            print(e)
+            traceback.print_exc()
             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"]
+                    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"
+            ) or "result" not in response:
+                raise BrokerException(f"[XTS_Error]: {response['description']}")
+
+            return response
+
+        except XTSTokenException as e:
+            raise TokenException(str(e))
+
+        except (TokenException, RetryableException, BrokerException):
+            raise
+
+        except (
+            XTSGeneralException,
+            XTSDataException,
+            XTSNetworkException,
+        ) as e:
+            raise BrokerException(str(e))
+
+        except Exception:
+            traceback.print_exc()
+            raise