quantplay 2.0.92__tar.gz → 2.0.94__tar.gz

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

@@ -1,36 +1,11 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.92
+Version: 2.0.94
 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.92 → quantplay-2.0.94}/quantplay/broker/dhan.py

@@ -102,14 +102,6 @@ class Dhan(Broker):
                 self.dhan.DAY,
             )
 
-            response = self.wrapper.modify_order(  # type: ignore
-                order_id=order_id,
-                variety=order["variety"],
-                price=order["price"],
-                trigger_price=order["trigger_price"],
-                order_type=order["order_type"],
-            )
-            return response  # type:ignore
         except Exception as e:
             exception_message = (
                 "OrderModificationFailed for {} failed with exception {}".format(
@@ -159,8 +151,7 @@ class Dhan(Broker):
             return dhanhq.CNC
         elif product == "MIS":
             return dhanhq.INTRA
-
-        raise InvalidArgumentException(f"Product {product} not supported for trading")
+        return product
 
     def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
         if symbol not in self.quantplay_symbol_map:
@@ -182,19 +173,25 @@ class Dhan(Broker):
         trigger_price: float | None = None,
     ) -> str | None:
         try:
-            Constants.logger.info(
-                f"[PLACING_ORDER] {tradingsymbol} {exchange} {quantity} {tag}"
-            )
             tradingsymbol = self.get_symbol(tradingsymbol)
             security_id = self.symbol_data[f"{exchange}:{tradingsymbol}"]["token"]
+            exchange_segment = self.get_exchange_segment(exchange)
+            dhan_order_type = self.get_order_type(order_type)
+            product_type = self.get_product(product)
+            Constants.logger.info(
+                f"[DHAN_PLACING_ORDER] {security_id} {exchange} {transaction_type} {quantity} {dhan_order_type} {product_type} {price} {trigger_price}"
+            )
+            if trigger_price is None:
+                trigger_price = 0
             order_id: str = self.dhan.place_order(  # type:ignore
                 security_id=security_id,  # hdfcbank
-                exchange_segment=self.get_exchange_segment(exchange),
+                exchange_segment=exchange_segment,
                 transaction_type=transaction_type,
                 quantity=quantity,
-                order_type=self.get_order_type(order_type),
-                product_type=self.get_product(product),
+                order_type=dhan_order_type,
+                product_type=product_type,
                 price=price,
+                trigger_price=trigger_price,  # type:ignore
             )
 
             return order_id  # type:ignore

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

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

@@ -250,6 +250,11 @@ 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)
 
@@ -375,6 +380,11 @@ 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:
@@ -685,6 +695,12 @@ 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.92 → quantplay-2.0.94}/quantplay/broker/xts.py

@@ -12,12 +12,6 @@ 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,
@@ -82,11 +76,8 @@ class XTS(Broker):
             self.load_instrument()
 
     def set_wrapper(self, serialized_wrapper: str, serialized_md_wrapper: str):
-        self.wrapper: XTSConnect = pickle.loads(
-            codecs.decode(serialized_wrapper.encode(), "base64")
-        )
-
-        self.md_wrapper: XTSConnect = pickle.loads(
+        self.wrapper = pickle.loads(codecs.decode(serialized_wrapper.encode(), "base64"))
+        self.md_wrapper = pickle.loads(
             codecs.decode(serialized_md_wrapper.encode(), "base64")
         )
 
@@ -110,34 +101,29 @@ 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):
@@ -147,53 +133,48 @@ class XTS(Broker):
                 secretKey=api_secret,
                 root=self.root_url,
             )
-            xt_core_response = self.invoke_xts_api(self.wrapper.interactive_login)
-
+            xt_core_response = self.wrapper.interactive_login()
             self.md_wrapper = XTSConnect(
                 apiKey=md_api_key,
                 secretKey=md_api_secret,
                 root=self.root_url,
             )
-            md_response = self.invoke_xts_api(self.md_wrapper.marketdata_login)
-
+            md_response = 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.invoke_xts_api(
-            self.wrapper.get_balance, clientID=self.ClientID
-        )
+        api_response = self.wrapper.get_balance(clientID=self.ClientID)
         self.handle_exception(api_response)
 
         if not api_response:
@@ -213,10 +194,14 @@ 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.invoke_xts_api(
-            self.wrapper.get_profile, clientID=self.ClientID
-        )
+        api_response = self.wrapper.get_profile(self.ClientID)
         self.handle_exception(api_response)
         api_response = api_response["result"]
 
@@ -228,10 +213,14 @@ 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.invoke_xts_api(
-            self.wrapper.get_order_book, clientID=self.ClientID
-        )
+        api_response = self.wrapper.get_order_book(self.ClientID)
         self.handle_exception(api_response)
 
         api_response = api_response["result"]
@@ -356,13 +345,22 @@ 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.invoke_xts_api(
-            self.wrapper.get_position_daywise, clientID=self.ClientID
-        )
+        api_response = self.wrapper.get_position_daywise(self.ClientID)
         self.handle_exception(api_response)
 
         api_response = api_response["result"]["positionList"]
@@ -480,9 +478,7 @@ class XTS(Broker):
             }
             for x in symbols
         ]
-
-        api_response = self.invoke_xts_api(
-            self.md_wrapper.get_quote,
+        api_response = self.md_wrapper.get_quote(
             Instruments=instruments,
             xtsMessageCode=1512,
             publishFormat="JSON",
@@ -490,7 +486,6 @@ 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"]
@@ -546,8 +541,7 @@ class XTS(Broker):
             "",  # TODO
         )
 
-        api_response = self.invoke_xts_api(
-            self.md_wrapper.get_quote,
+        api_response = self.md_wrapper.get_quote(
             Instruments=[
                 {
                     "exchangeSegment": exchange_code,
@@ -567,7 +561,6 @@ class XTS(Broker):
 
         try:
             ltp_json = api_response["listQuotes"][0]
-
         except IndexError as e:
             print(api_response, e)
             raise BrokerException("Broker Provided Invalid Response")
@@ -600,8 +593,7 @@ class XTS(Broker):
         if tag is None:
             tag = ""
 
-        api_response = self.invoke_xts_api(
-            self.wrapper.place_order,
+        api_response = self.wrapper.place_order(
             exchangeSegment=exchange_name,
             exchangeInstrumentID=exchange_token,
             orderType=xts_order_type,
@@ -634,8 +626,7 @@ class XTS(Broker):
 
         tag = order_data["tag"]
 
-        api_response = self.invoke_xts_api(
-            self.wrapper.cancel_order,
+        api_response = self.wrapper.cancel_order(
             appOrderID=int(order_id),
             clientID=order_data["user_id"],
             orderUniqueIdentifier=tag,
@@ -687,8 +678,7 @@ class XTS(Broker):
         time_in_force = "DAY"
         disclosed_quantity = 0
 
-        api_response = self.invoke_xts_api(
-            self.wrapper.modify_order,
+        api_response = self.wrapper.modify_order(
             appOrderID=int(order_id),
             modifiedTimeInForce=time_in_force,
             modifiedDisclosedQuantity=disclosed_quantity,
@@ -816,49 +806,3 @@ 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