quantplay 2.0.36__tar.gz → 2.0.38__tar.gz

{quantplay-2.0.36 → quantplay-2.0.38}/PKG-INFO

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

{quantplay-2.0.36 → quantplay-2.0.38}/quantplay/broker/aliceblue.py

@@ -3,13 +3,16 @@ import copy
 import pickle
 from queue import Queue
 import traceback
-from typing import Any, Callable, Dict, Literal
+from typing import Any, Dict, Literal
 
 import polars as pl
-from pya3 import Aliceblue as Alice
-from pya3 import OrderType as AliceOrderType
-from pya3 import ProductType, TransactionType
-from retrying import retry
+from pya3 import (
+    Aliceblue as Alice,
+    OrderType as AliceOrderType,
+    TransactionType as AliceTransactionType,
+    ProductType as AliceProductType,
+)
+from retrying import retry  # type: ignore
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.exception.exceptions import (
@@ -20,7 +23,12 @@ from quantplay.exception.exceptions import (
     retry_exception,
 )
 from quantplay.model.broker import ModifyOrderRequest, UserBrokerProfileResponse
-from quantplay.model.generics import ExchangeType
+from quantplay.model.generics import (
+    ExchangeType,
+    OrderTypeType,
+    ProductType,
+    TransactionType,
+)
 from quantplay.model.order_event import OrderUpdateEvent
 from quantplay.utils.constant import Constants, OrderType
 from quantplay.utils.pickle_utils import InstrumentData
@@ -41,7 +49,7 @@ class Aliceblue(Broker):
         user_id: str | None = None,
         api_key: str | None = None,
         order_updates: Queue[OrderUpdateEvent] | None = None,
-        client=None,
+        client: str | None = None,
     ):
         super(Aliceblue, self).__init__()
         self.order_updates = order_updates
@@ -60,37 +68,36 @@ class Aliceblue(Broker):
                 )
                 response = self.alice.get_session_id()
 
-                if "sessionID" not in response or response["sessionID"] is None:
+                if response.get("sessionID") is None:
                     if "emsg" in response:
                         if response["emsg"].lower() == "invalid input":
                             response["emsg"] = "Invalid broker credentials"
                         raise InvalidArgumentException(response["emsg"])
                     raise InvalidArgumentException(f"Invalid API Key {api_key}")
+
         except (InvalidArgumentException, TokenException):
             raise
+
         except Exception as e:
             raise RetryableException(str(e))
+
         self.user_id = self.alice.user_id
         self.load_instrument()
 
-    def set_client(self, serialized_client):
+    def set_client(self, serialized_client: str):
         try:
-            self.alice = pickle.loads(codecs.decode(serialized_client.encode(), "base64"))
+            self.alice: Alice = pickle.loads(
+                codecs.decode(serialized_client.encode(), "base64")
+            )
         except Exception:
             raise TokenException("Session expired")
 
-    def set_attributes(self, response):
-        self.email = response["email"]
-        self.user_id = response["actid"]
-        self.full_name = response["uname"]
-        self.user_token = response["susertoken"]
-
-    def get_quantplay_symbol(self, symbol):
+    def get_quantplay_symbol(self, symbol: str):
         if "-EQ" in symbol:
             return symbol.replace("-EQ", "")
         return symbol
 
-    def get_symbol(self, symbol, exchange=None):
+    def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
         if exchange == "NSE":
             if "-EQ" not in symbol:
                 return f"{symbol}-EQ"
@@ -118,55 +125,63 @@ class Aliceblue(Broker):
 
     def get_transaction_type(
         self,
-        transaction_type: Literal["BUY", "SELL", "B", "S"],
+        transaction_type: Literal[
+            "BUY", "SELL", "B", "S", AliceTransactionType.Buy, AliceTransactionType.Sell
+        ],
     ):
         if (
             transaction_type == "BUY"
-            or transaction_type == TransactionType.Buy.value
+            or transaction_type == AliceTransactionType.Buy
             or transaction_type == "B"
         ):
-            return TransactionType.Buy
+            return AliceTransactionType.Buy
         elif (
             transaction_type == "SELL"
-            or transaction_type == TransactionType.Sell.value
+            or transaction_type == AliceTransactionType.Sell
             or transaction_type == "S"
         ):
-            return TransactionType.Sell
+            return AliceTransactionType.Sell
 
         raise InvalidArgumentException(
             f"transaction type {transaction_type} not supported for trading"
         )
 
-    def get_order_type(self, order_type):
-        if order_type == OrderType.market or order_type == AliceOrderType.Market.value:
+    def get_order_type(
+        self,
+        order_type: (
+            OrderTypeType
+            | Literal[
+                AliceOrderType.Market,
+                AliceOrderType.StopLossLimit,
+                AliceOrderType.StopLossMarket,
+                AliceOrderType.Limit,
+            ]
+        ),
+    ):
+        if order_type == OrderType.market or order_type == AliceOrderType.Market:
             return AliceOrderType.Market
-        elif (
-            order_type == OrderType.sl or order_type == AliceOrderType.StopLossLimit.value
-        ):
+        elif order_type == OrderType.sl or order_type == AliceOrderType.StopLossLimit:
             return AliceOrderType.StopLossLimit
-        elif (
-            order_type == OrderType.slm
-            or order_type == AliceOrderType.StopLossMarket.value
-        ):
+        elif order_type == OrderType.slm or order_type == AliceOrderType.StopLossMarket:
             return AliceOrderType.StopLossMarket
-        elif order_type == OrderType.limit or order_type == AliceOrderType.Limit.value:
+        elif order_type == OrderType.limit or order_type == AliceOrderType.Limit:
             return AliceOrderType.Limit
 
         return order_type
 
-    def get_product(self, product):
+    def get_product(self, product: ProductType):
         if product == "NRML":
-            return ProductType.Normal
+            return AliceProductType.Normal
         elif product == "CNC":
-            return ProductType.Delivery
+            return AliceProductType.Delivery
         elif product == "MIS":
-            return ProductType.Intraday
+            return AliceProductType.Intraday
         elif product in [
-            ProductType.BracketOrder,
-            ProductType.CoverOrder,
-            ProductType.Delivery,
-            ProductType.Normal,
-            ProductType.Intraday,
+            AliceProductType.BracketOrder,
+            AliceProductType.CoverOrder,
+            AliceProductType.Delivery,
+            AliceProductType.Normal,
+            AliceProductType.Intraday,
         ]:
             return product
 
@@ -174,15 +189,15 @@ class Aliceblue(Broker):
 
     def place_order(
         self,
-        tradingsymbol=None,
-        exchange=None,
-        quantity=None,
-        order_type=None,
-        transaction_type=None,
-        tag=None,
-        product=None,
-        price=None,
-        trigger_price=None,
+        tradingsymbol: str,
+        exchange: ExchangeType,
+        quantity: int,
+        order_type: OrderTypeType,
+        transaction_type: TransactionType,
+        tag: str | None,
+        product: ProductType,
+        price: float,
+        trigger_price: float | None = None,
     ):
         try:
             if trigger_price == 0:
@@ -190,8 +205,8 @@ class Aliceblue(Broker):
             if trigger_price is not None:
                 trigger_price = float(trigger_price)
 
-            order_type = self.get_order_type(order_type)
-            product = self.get_product(product)
+            aliceblue_order_type = self.get_order_type(order_type)
+            aliceblue_product = self.get_product(product)
             tradingsymbol = self.get_symbol(tradingsymbol)
 
             instrument = self.alice.get_instrument_by_symbol(exchange, tradingsymbol)
@@ -199,9 +214,9 @@ class Aliceblue(Broker):
             response = self.invoke_aliceblue_api(
                 self.alice.place_order,
                 transaction_type=self.get_transaction_type(transaction_type),
-                product_type=product,
+                product_type=aliceblue_product,
                 instrument=instrument,
-                order_type=order_type,
+                order_type=aliceblue_order_type,
                 quantity=quantity,
                 price=float(price),
                 trigger_price=trigger_price,
@@ -237,12 +252,13 @@ class Aliceblue(Broker):
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
     )
-    def modify_order(self, order_to_modify: ModifyOrderRequest) -> str:
-        data = copy.deepcopy(order_to_modify)
+    def modify_order(self, order: ModifyOrderRequest) -> str:
+        data = copy.deepcopy(order)
         order_id = data["order_id"]
         try:
             order_history = self.invoke_aliceblue_api(
-                self.alice.get_order_history, nextorder=order_id
+                self.alice.get_order_history,
+                nextorder=order_id,
             )
 
             # TODO: None,str Raise
@@ -254,7 +270,12 @@ class Aliceblue(Broker):
             order_type = order_history["Prctype"]
             if "order_type" in data:
                 order_type = data["order_type"]
-            order_type = self.get_order_type(order_type)
+
+            aliceblue_order_type = (
+                self.get_order_type(order_type)
+                if order_type
+                else order_history["Prctype"]
+            )
 
             transaction_type = order_history["Trantype"]
             if "transaction_type" in data:
@@ -265,17 +286,17 @@ class Aliceblue(Broker):
             if "trigger_price" in data and data["trigger_price"] is not None:
                 trigger_price = float(data["trigger_price"])
 
-            self.alice.modify_order(
+            response = self.alice.modify_order(
                 instrument=self.alice.get_instrument_by_token(exchange, token),
                 transaction_type=transaction_type,
                 order_id=order_id,
                 product_type=product_type,
-                order_type=order_type,
-                price=float(data["price"]),
-                trigger_price=trigger_price,  # type: ignore
+                order_type=aliceblue_order_type,
+                price=float(data.get("price", 0)),
+                trigger_price=trigger_price,
                 quantity=quantity,
             )
-            logger.info("[MODIFY_ORDER_RESPONSE] [{order_id}]  response [{response}]")
+            logger.info(f"[MODIFY_ORDER_RESPONSE] [{order_id}]  response [{response}]")
         except Exception as e:
             print(traceback.print_exc())
             Constants.logger.error(
@@ -283,20 +304,27 @@ class Aliceblue(Broker):
             )
         return order_id
 
-    def modify_price(self, order_id, price, trigger_price=None, order_type=None):
-        data = {}
+    def modify_price(
+        self,
+        order_id: str,
+        price: float,
+        trigger_price: float | None = None,
+        order_type: OrderTypeType | None = None,
+    ):
+        data: ModifyOrderRequest = {
+            "order_id": order_id,
+            "price": price,
+            "order_type": order_type,
+        }
 
-        data["order_id"] = order_id
-        data["price"] = price
-        data["order_type"] = order_type
         if trigger_price is not None and trigger_price > 0:
             data["trigger_price"] = trigger_price
         else:
             data["trigger_price"] = None
 
-        self.modify_order(data)  # type: ignore
+        self.modify_order(data)
 
-    def cancel_order(self, order_id: str, variety=None) -> None:
+    def cancel_order(self, order_id: str, variety: str | None = None) -> None:
         self.invoke_aliceblue_api(self.alice.cancel_order, nestordernmbr=order_id)
 
     def profile(self):
@@ -573,7 +601,7 @@ class Aliceblue(Broker):
 
         return margins
 
-    def invoke_aliceblue_api(self, fn: Callable, *args, **kwargs) -> Any:
+    def invoke_aliceblue_api(self, fn: Any, *args: Any, **kwargs: Any) -> Any:
         try:
             response = fn(*args, **kwargs)
 

{quantplay-2.0.36 → quantplay-2.0.38}/quantplay/broker/angelone.py

@@ -1,18 +1,16 @@
 import binascii
-import codecs
 import copy
 import json
-import pickle
 from queue import Queue
 import traceback
-from typing import Any, Callable, Dict
+from typing import Any, Dict
 
-from SmartApi.smartExceptions import DataException
+from SmartApi.smartExceptions import DataException  # type: ignore
 import polars as pl
 import pyotp
 from requests.exceptions import ConnectionError, ConnectTimeout
 from retrying import retry  # type: ignore
-from SmartApi import SmartConnect
+from SmartApi import SmartConnect  # type: ignore
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.exception.exceptions import (
@@ -25,6 +23,12 @@ from quantplay.exception.exceptions import (
     retry_exception,
 )
 from quantplay.model.broker import ModifyOrderRequest, UserBrokerProfileResponse
+from quantplay.model.generics import (
+    ExchangeType,
+    OrderTypeType,
+    ProductType,
+    TransactionType,
+)
 from quantplay.model.order_event import OrderUpdateEvent
 from quantplay.utils.constant import Constants, OrderType
 from quantplay.utils.exchange import Market as MarketConstants
@@ -71,7 +75,7 @@ class AngelOne(Broker):
                     raise InvalidArgumentException("TOTP Key is Missing")
                 self.wrapper = SmartConnect(api_key=api_key)
                 response = self.invoke_angelone_api(
-                    self.wrapper.generateSession,
+                    self.wrapper.generateSession,  # type: ignore
                     clientCode=user_id,
                     password=mpin,
                     totp=pyotp.TOTP(totp).now(),
@@ -81,32 +85,27 @@ class AngelOne(Broker):
                         raise InvalidArgumentException(response["message"])
                     raise InvalidArgumentException("Invalid API credentials")
                 token_data = self.invoke_angelone_api(
-                    self.wrapper.generateToken, refresh_token=self.wrapper.refresh_token
+                    self.wrapper.generateToken,  # type: ignore
+                    refresh_token=self.wrapper.refresh_token,  # type: ignore
                 )
                 self.refresh_token = token_data["data"]["refreshToken"]
+
         except InvalidArgumentException:
             raise
+
         except binascii.Error:
             raise InvalidArgumentException("Invalid TOTP key provided")
+
         except Exception as e:
             print(e)
             raise RetryableException(str(e))
 
         self.user_id = user_id
-        self.api_key = self.wrapper.api_key
+        self.api_key = self.wrapper.api_key  # type: ignore
 
         if load_instrument:
             self.load_instrument()
 
-    def set_wrapper(self, serialized_wrapper):
-        self.wrapper: SmartConnect = pickle.loads(
-            codecs.decode(serialized_wrapper.encode(), "base64")
-        )
-
-    def handle_exception(self, response):
-        if "errorCode" in response and response["errorCode"] == "AG8001":
-            raise TokenException(f"{self.user_id}: Invalid Token")
-
     def load_instrument(self, file_name: str | None = None) -> None:
         try:
             instrument_data_instance = InstrumentData.get_instance()
@@ -124,7 +123,7 @@ class AngelOne(Broker):
 
         self.initialize_broker_symbol_map()
 
-    def get_symbol(self, symbol: str, exchange=None):
+    def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
         if exchange == "NSE":
             if symbol in ["NIFTY", "BANKNIFTY"]:
                 return symbol
@@ -139,7 +138,7 @@ class AngelOne(Broker):
             return symbol
         return self.quantplay_symbol_map[symbol]
 
-    def get_order_type(self, order_type):
+    def get_order_type(self, order_type: OrderTypeType | None):
         if order_type == OrderType.sl:
             return AngelOne.order_sl
         elif order_type == OrderType.slm:
@@ -147,7 +146,7 @@ class AngelOne(Broker):
 
         return order_type
 
-    def get_product(self, product):
+    def get_product(self, product: ProductType):
         if product == "NRML":
             return "CARRYFORWARD"
         elif product == "CNC":
@@ -159,7 +158,7 @@ class AngelOne(Broker):
 
         raise InvalidArgumentException(f"Product {product} not supported for trading")
 
-    def ltp(self, exchange, tradingsymbol: str) -> float:
+    def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
         if tradingsymbol in MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP:
             tradingsymbol = MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP[
                 tradingsymbol
@@ -171,7 +170,7 @@ class AngelOne(Broker):
         symboltoken = symbol_data["token"]
 
         response = self.invoke_angelone_api(
-            self.wrapper.ltpData,
+            self.wrapper.ltpData,  # type: ignore
             exchange=exchange,
             tradingsymbol=tradingsymbol,
             symboltoken=symboltoken,
@@ -181,23 +180,23 @@ class AngelOne(Broker):
 
     def place_order(
         self,
-        tradingsymbol=None,
-        exchange=None,
-        quantity=None,
-        order_type=None,
-        transaction_type=None,
-        tag=None,
-        product=None,
-        price=None,
-        trigger_price=None,
+        tradingsymbol: str,
+        exchange: ExchangeType,
+        quantity: int,
+        order_type: OrderTypeType,
+        transaction_type: TransactionType,
+        tag: str | None,
+        product: ProductType,
+        price: float,
+        trigger_price: float | None = None,
     ):
         order = {}
         try:
             if trigger_price == 0:
                 trigger_price = None
 
-            order_type = self.get_order_type(order_type)
-            product = self.get_product(product)
+            angelone_order_type = self.get_order_type(order_type)
+            angelone_product = self.get_product(product)
             tradingsymbol = self.get_symbol(tradingsymbol, exchange=exchange)
 
             variety = "NORMAL"
@@ -211,11 +210,11 @@ class AngelOne(Broker):
                 "transactiontype": transaction_type,
                 "variety": variety,
                 "tradingsymbol": tradingsymbol,
-                "ordertype": order_type,
+                "ordertype": angelone_order_type,
                 "triggerprice": trigger_price,
                 "exchange": exchange,
                 "symboltoken": symbol_token,
-                "producttype": product,
+                "producttype": angelone_product,
                 "price": price,
                 "quantity": quantity,
                 "duration": "DAY",
@@ -223,7 +222,7 @@ class AngelOne(Broker):
             }
 
             Constants.logger.info(f"[PLACING_ORDER] {json.dumps(order)}")
-            return self.invoke_angelone_api(self.wrapper.placeOrder, orderparams=order)
+            return self.invoke_angelone_api(self.wrapper.placeOrder, orderparams=order)  # type: ignore
 
         except (TimeoutError, ConnectTimeout):
             Constants.logger.info(f"[ANGELONE_REQUEST_TIMEOUT] {order}")
@@ -233,7 +232,7 @@ class AngelOne(Broker):
             Constants.logger.error(f"[PLACE_ORDER_FAILED] {e} {order}")
             raise QuantplayOrderPlacementException(str(e))
 
-    def get_variety(self, variety):
+    def get_variety(self, variety: str):
         if variety == "regular":
             return "NORMAL"
         return variety
@@ -243,19 +242,19 @@ class AngelOne(Broker):
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
     )
-    def modify_order(self, order_to_modify: ModifyOrderRequest) -> str:
-        data = copy.deepcopy(order_to_modify)
+    def modify_order(self, order: ModifyOrderRequest) -> str:
+        data = copy.deepcopy(order)
         order_id = str(data["order_id"])
         try:
             orders = self.orders()
             filtered_order = orders.filter(pl.col("order_id") == str(data["order_id"]))
-            order = filtered_order.to_dicts()[0]
-            quantity = order["quantity"]
-            token = order["token"]
-            exchange = order["exchange"]
-            product = self.get_product(order["product"])
-            variety = order["variety"]
-            order_type = self.get_order_type(data["order_type"])
+            order_data = filtered_order.to_dicts()[0]
+            quantity = order_data["quantity"]
+            token = order_data["token"]
+            exchange = order_data["exchange"]
+            product = self.get_product(order_data["product"])
+            variety = order_data["variety"]
+            order_type = self.get_order_type(data.get("order_type"))
 
             if "trigger_price" not in data:
                 data["trigger_price"] = None
@@ -268,7 +267,7 @@ class AngelOne(Broker):
             order_params = {
                 "orderid": order_id,
                 "variety": variety,
-                "price": data["price"],
+                "price": data.get("price"),
                 "triggerprice": data["trigger_price"],
                 "producttype": product,
                 "duration": "DAY",
@@ -277,13 +276,14 @@ class AngelOne(Broker):
                 "ordertype": order_type,
                 "exchange": exchange,
                 "tradingsymbol": self.get_symbol(
-                    order["tradingsymbol"], exchange=exchange
+                    order_data["tradingsymbol"], exchange=exchange
                 ),
             }
 
             Constants.logger.info(f"Modifying order [{order_id}] params [{order_params}]")
             response = self.invoke_angelone_api(
-                self.wrapper.modifyOrder, orderparams=order_params
+                self.wrapper.modifyOrder,
+                orderparams=order_params,
             )
             Constants.logger.info(f"[MODIFY_ORDER_RESPONSE] {response}")
             return order_id
@@ -294,8 +294,8 @@ class AngelOne(Broker):
             )
             raise
 
-    def cancel_order(self, order_id, variety="NORMAL"):
-        self.wrapper.cancelOrder(order_id=order_id, variety=variety)
+    def cancel_order(self, order_id: str, variety: str | None = "NORMAL"):
+        self.wrapper.cancelOrder(order_id=order_id, variety=variety)  # type: ignore
 
     def holdings(self):
         holdings = self.invoke_angelone_api(self.wrapper.holding)
@@ -499,7 +499,8 @@ class AngelOne(Broker):
 
     def profile(self):
         profile_data = self.invoke_angelone_api(
-            self.wrapper.getProfile, refreshToken=self.refresh_token
+            self.wrapper.getProfile,  # type: ignore
+            refreshToken=self.refresh_token,
         )
 
         profile_data = profile_data["data"]
@@ -561,7 +562,7 @@ class AngelOne(Broker):
         stop_max_attempt_number=3,
         retry_on_exception=retry_exception,
     )
-    def invoke_angelone_api(self, fn: Callable, *args, **kwargs) -> Any:
+    def invoke_angelone_api(self, fn: Any, *args: Any, **kwargs: Any) -> Any:
         try:
             response = fn(*args, **kwargs)
             if "errorCode" in response and response["errorCode"] == "AG8001":