quantplay 2.0.32__tar.gz → 2.0.33__tar.gz

{quantplay-2.0.32 → quantplay-2.0.33}/PKG-INFO

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

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/aliceblue.py

@@ -110,15 +110,16 @@ class Aliceblue(Broker):
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
         except Exception:
             self.instrument_data = S3Utils.read_csv(
-                "quantplay-market-data",
-                "symbol_data/aliceblue_instruments.csv",
-                read_from_local=False,
+                "quantplay-market-data", "symbol_data/aliceblue_instruments.csv"
             )
             self.initialize_symbol_data(save_as="aliceblue_instruments")
 
         self.initialize_broker_symbol_map()
 
-    def get_transaction_type(self, transaction_type: Literal["BUY", "SELL"]):
+    def get_transaction_type(
+        self,
+        transaction_type: Literal["BUY", "SELL", "B", "S"],
+    ):
         if (
             transaction_type == "BUY"
             or transaction_type == TransactionType.Buy.value

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/angelone.py

@@ -7,6 +7,7 @@ from queue import Queue
 import traceback
 from typing import Callable, Dict
 
+from SmartApi.smartExceptions import DataException
 import polars as pl
 import pyotp
 from requests.exceptions import ConnectionError, ConnectTimeout
@@ -118,7 +119,6 @@ class AngelOne(Broker):
             self.instrument_data = S3Utils.read_csv(
                 "quantplay-market-data",
                 "symbol_data/angelone_instruments.csv",
-                read_from_local=False,
             )
             self.initialize_symbol_data(save_as="angelone_instruments")
 
@@ -576,6 +576,9 @@ class AngelOne(Broker):
             return response
         except (TokenException, InvalidArgumentException):
             raise
+        except DataException as e:
+            # TODO: Catch and Check for Others Exceptions
+            raise BrokerException(str(e))
         except Exception:
             traceback.print_exc()
             raise RetryableException("Failed to fetch user profile")

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/auto_login/aliceblue.py

@@ -79,8 +79,6 @@ class AliceblueLogin:
         try:
             driver = Selenium().get_browser(headless=True)
 
-            # TODO api should be fetched from configuration
-
             driver.get("https://ant.aliceblueonline.com/")
             AliceblueLogin.click_on_login(driver)
             AliceblueLogin.enter_user_id(driver, user_id)

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/finvasia_utils/fa_noren.py

@@ -7,7 +7,7 @@ import time
 import urllib.parse
 from datetime import datetime as dt
 from time import sleep
-from typing import Literal
+from typing import Dict, Literal, TypedDict
 
 import requests
 import websocket
@@ -55,20 +55,26 @@ class BuyorSell:
     Sell = "S"
 
 
-def reportmsg(msg):
+def reportmsg(msg: str):
     logger.debug(msg)
 
 
-def reporterror(msg):
+def reporterror(msg: str):
     logger.error(msg)
 
 
-def reportinfo(msg):
+def reportinfo(msg: str):
     logger.info(msg)
 
 
+class FAServiceConfig(TypedDict):
+    host: str
+    routes: Dict[str, str]
+    websocket_endpoint: str
+
+
 class FA_NorenApi:
-    __service_config = {
+    __service_config: FAServiceConfig = {
         "host": "http://wsapihost/",
         "routes": {
             "authorize": "/QuickAuth",
@@ -123,18 +129,18 @@ class FA_NorenApi:
 
         while not self.__stop_event.is_set():
             try:
-                self.__websocket.run_forever(ping_interval=3, ping_payload='{"t":"h"}')
+                self.__websocket.run_forever(ping_interval=3, ping_payload='{"t":"h"}')  # type: ignore
             except Exception:
                 pass
 
             sleep(0.1)
 
-    def __ws_send(self, *args, **kwargs):
+    def __ws_send(self, data: str | bytes):
         while not self.__websocket_connected or self.__websocket is None:
             sleep(0.05)
 
         with self.__ws_mutex:
-            ret = self.__websocket.send(*args, **kwargs)
+            ret = self.__websocket.send(data)
 
         return ret
 
@@ -235,7 +241,7 @@ class FA_NorenApi:
 
         self.__stop_event.set()
         self.__websocket_connected = False
-        self.__websocket.close()
+        self.__websocket.close()  # type: ignore
         self.__ws_thread.join()
 
     def login(
@@ -941,7 +947,7 @@ class FA_NorenApi:
 
         headers = {"Content-Type": "application/json; charset=utf-8"}
         res = requests.post(url, data=payload, headers=headers)
-        reportmsg(res)
+        reportmsg(str(res))
 
         if res.status_code != 200:
             return None

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/ft_utils/flattrade_utils.py

@@ -12,6 +12,7 @@ from quantplay.exception.exceptions import (
     WrongLibrarySetup,
     retry_exception,
 )
+from quantplay.utils.constant import Constants
 from quantplay.utils.selenium_utils import Selenium
 
 
@@ -56,7 +57,14 @@ class FlatTradeUtils:
             time.sleep(2)
 
             url = driver.current_url
-            request_token = url.split("code=")[1].split("&")[0]
+
+            try:
+                # TODO: IndexError: list index out of range
+                request_token = url.split("code=")[1].split("&")[0]
+            except Exception as e:
+                Constants.logger.error(f"Flattrade Selenium Error for {url}")
+                traceback.print_exc()
+                raise e
 
             driver.close()
 

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/ft_utils/ft_noren.py

@@ -7,7 +7,7 @@ import time
 import urllib.parse
 from datetime import datetime as dt
 from time import sleep
-from typing import Literal
+from typing import Dict, Literal, TypedDict
 
 import requests
 import websocket
@@ -55,20 +55,26 @@ class BuyorSell:
     Sell = "S"
 
 
-def reportmsg(msg):
+def reportmsg(msg: str):
     logger.debug(msg)
 
 
-def reporterror(msg):
+def reporterror(msg: str):
     logger.error(msg)
 
 
-def reportinfo(msg):
+def reportinfo(msg: str):
     logger.info(msg)
 
 
+class FTServiceConfig(TypedDict):
+    host: str
+    routes: Dict[str, str]
+    websocket_endpoint: str
+
+
 class FT_NorenApi:
-    __service_config = {
+    __service_config: FTServiceConfig = {
         "host": "http://wsapihost/",
         "routes": {
             "authorize": "/QuickAuth",
@@ -102,7 +108,7 @@ class FT_NorenApi:
         "websocket_endpoint": "wss://wsendpoint/",
     }
 
-    def __init__(self, host, websocket_endpoint):
+    def __init__(self, host: str, websocket_endpoint: str):
         self.__service_config["host"] = host
         self.__service_config["websocket_endpoint"] = websocket_endpoint
 
@@ -121,18 +127,18 @@ class FT_NorenApi:
 
         while not self.__stop_event.is_set():
             try:
-                self.__websocket.run_forever(ping_interval=3, ping_payload='{"t":"h"}')
+                self.__websocket.run_forever(ping_interval=3, ping_payload='{"t":"h"}')  # type: ignore
             except Exception:
                 pass
 
             sleep(0.1)
 
-    def __ws_send(self, *args, **kwargs):
+    def __ws_send(self, data: bytes | str):
         while not self.__websocket_connected or self.__websocket is None:
             sleep(0.05)
 
         with self.__ws_mutex:
-            ret = self.__websocket.send(*args, **kwargs)
+            ret = self.__websocket.send(data)
         return ret
 
     def __on_close_callback(self, wsapp, close_status_code, close_msg):
@@ -232,7 +238,7 @@ class FT_NorenApi:
 
         self.__stop_event.set()
         self.__websocket_connected = False
-        self.__websocket.close()
+        self.__websocket.close()  # type: ignore
         self.__ws_thread.join()
 
     def login(
@@ -336,7 +342,7 @@ class FT_NorenApi:
 
         return resDict
 
-    def subscribe(self, instrument, feed_type=FeedType.TOUCHLINE):
+    def subscribe(self, instrument, feed_type: int = FeedType.TOUCHLINE):
         values = {}
 
         if feed_type == FeedType.TOUCHLINE:
@@ -355,7 +361,7 @@ class FT_NorenApi:
 
         self.__ws_send(data)
 
-    def unsubscribe(self, instrument, feed_type=FeedType.TOUCHLINE):
+    def unsubscribe(self, instrument, feed_type: int = FeedType.TOUCHLINE):
         values = {}
 
         if feed_type == FeedType.TOUCHLINE:
@@ -934,7 +940,7 @@ class FT_NorenApi:
 
         headers = {"Content-Type": "application/json; charset=utf-8"}
         res = requests.post(url, data=payload, headers=headers)
-        reportmsg(res)
+        reportmsg(str(res))
 
         if res.status_code != 200:
             return None

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/generics/broker.py

@@ -30,10 +30,10 @@ from quantplay.exception.exceptions import (
 )
 from quantplay.model.broker import (
     ExchangeType,
-    ModifyOrderRequest,
     UserBrokerProfileResponse,
 )
 from quantplay.model.generics import ProductType, TransactionType, OrderTypeType
+from quantplay.model.instrument_data import InstrumentDataType
 from quantplay.model.order_event import OrderUpdateEvent
 from quantplay.utils.constant import Constants
 from quantplay.utils.exchange import Market as MarketConstants
@@ -158,15 +158,16 @@ class Broker:
             raise StaleDataFound(f"Couldn't find symbol data for [{exchange}:{symbol}]")
 
     def initialize_symbol_data(self, save_as: str | None = None) -> None:
-        instruments = self.instrument_data
-        instruments = instruments.to_dict("records")
-        self.symbol_data = {}
+        instruments_df = self.instrument_data
+        instruments: List[InstrumentDataType] = instruments_df.to_dict("records")  # type: ignore
+
+        self.symbol_data: Dict[str, InstrumentDataType] = {}
         for instrument in instruments:
             exchange = instrument["exchange"]
             tradingsymbol = instrument["broker_symbol"]
 
             instrument_data = copy.deepcopy(instrument)
-            self.symbol_data["{}:{}".format(exchange, tradingsymbol)] = instrument_data
+            self.symbol_data[f"{exchange}:{tradingsymbol}"] = instrument_data
 
         if save_as:
             PickleUtils.save_data(self.symbol_data, save_as)
@@ -202,13 +203,12 @@ class Broker:
             self.instrument_data = S3Utils.read_csv(
                 "quantplay-market-data",
                 f"symbol_data/{file_name}.csv",
-                read_from_local=False,
             )
             self.initialize_symbol_data(save_as=file_name)
 
         self.initialize_broker_symbol_map()
 
-    def round_to_tick(self, number):
+    def round_to_tick(self, number: int | float) -> float:
         return round(number * 20) / 20
 
     def get_user_id(self):
@@ -236,64 +236,66 @@ class Broker:
         seg_condition = [
             (
                 (self.instrument_data["instrument"].str.contains("FUT"))
-                & (self.instrument_data.instrument != "OPTFUT")
+                & (self.instrument_data["instrument"] != "OPTFUT")
             )
         ]
 
         tradingsymbol = [
-            self.instrument_data.tradingsymbol
-            + self.instrument_data.expiry_year
-            + self.instrument_data.month
+            self.instrument_data["tradingsymbol"]
+            + self.instrument_data["expiry_year"]
+            + self.instrument_data["month"]
             + "FUT"
         ]
 
         self.instrument_data.loc[:, "tradingsymbol"] = np.select(
-            seg_condition, tradingsymbol, default=self.instrument_data.tradingsymbol
+            seg_condition, tradingsymbol, default=self.instrument_data["tradingsymbol"]
         )
 
     def add_quantplay_opt_tradingsymbol(self):
         seg_condition = self.instrument_data["strike_price"] > 0
         weekly_option_condition = (
-            self.instrument_data.expiry.dt.month
-            == self.instrument_data.next_expiry.dt.month
-        ) & (self.instrument_data.exchange == "NFO")
+            self.instrument_data["expiry"].dt.month
+            == self.instrument_data["next_expiry"].dt.month
+        ) & (self.instrument_data["exchange"] == "NFO")
         month_option_condition = (
-            self.instrument_data.expiry.dt.month
-            != self.instrument_data.next_expiry.dt.month
-        ) | (self.instrument_data.exchange == "MCX")
+            self.instrument_data["expiry"].dt.month
+            != self.instrument_data["next_expiry"].dt.month
+        ) | (self.instrument_data["exchange"] == "MCX")
 
         self.instrument_data.loc[:, "tradingsymbol"] = np.where(
             seg_condition,
-            self.instrument_data.tradingsymbol + self.instrument_data.expiry_year,
-            self.instrument_data.tradingsymbol,
+            self.instrument_data["tradingsymbol"] + self.instrument_data["expiry_year"],
+            self.instrument_data["tradingsymbol"],
         )
 
         self.instrument_data.loc[:, "tradingsymbol"] = np.where(
             seg_condition & weekly_option_condition,
-            self.instrument_data.tradingsymbol + self.instrument_data.week_option_prefix,
-            self.instrument_data.tradingsymbol,
+            self.instrument_data["tradingsymbol"]
+            + self.instrument_data["week_option_prefix"],
+            self.instrument_data["tradingsymbol"],
         )
 
         self.instrument_data.loc[:, "tradingsymbol"] = np.where(
             seg_condition & month_option_condition,
-            self.instrument_data.tradingsymbol + self.instrument_data.month,
-            self.instrument_data.tradingsymbol,
+            self.instrument_data["tradingsymbol"] + self.instrument_data["month"],
+            self.instrument_data["tradingsymbol"],
         )
 
         self.instrument_data.loc[:, "tradingsymbol"] = np.where(
             seg_condition,
-            self.instrument_data.tradingsymbol
-            + self.instrument_data.strike_price.astype(float)
+            self.instrument_data["tradingsymbol"]
+            + self.instrument_data["strike_price"]
+            .astype(float)
             .astype(str)
             .str.split(".")
             .str[0],
-            self.instrument_data.tradingsymbol,
+            self.instrument_data["tradingsymbol"],
         )
 
         self.instrument_data.loc[:, "tradingsymbol"] = np.where(
             seg_condition,
-            self.instrument_data.tradingsymbol + self.instrument_data.option_type,
-            self.instrument_data.tradingsymbol,
+            self.instrument_data["tradingsymbol"] + self.instrument_data["option_type"],
+            self.instrument_data["tradingsymbol"],
         )
 
     def get_df_from_zip(self, url: str):
@@ -308,11 +310,11 @@ class Broker:
         return pd.read_csv("/tmp/{}.csv".format(file_name))
 
     def initialize_expiry_fields(self):
-        self.instrument_data.loc[:, "tradingsymbol"] = (
-            self.instrument_data.instrument_symbol
-        )
+        self.instrument_data.loc[:, "tradingsymbol"] = self.instrument_data[
+            "instrument_symbol"
+        ]
         self.instrument_data.loc[:, "expiry"] = pd.to_datetime(
-            self.instrument_data.instrument_expiry
+            self.instrument_data["instrument_expiry"]
         )
 
         self.instrument_data.loc[:, "expiry_year"] = (
@@ -326,42 +328,42 @@ class Broker:
             self.instrument_data["expiry"].dt.strftime("%m").astype(float).astype(str)
         )
         self.instrument_data.loc[:, "month_number"] = np.where(
-            self.instrument_data.month_number == "nan",
+            self.instrument_data["month_number"] == "nan",
             np.nan,
-            self.instrument_data.month_number.str.split(".").str[0],
+            self.instrument_data["month_number"].str.split(".").str[0],
         )
 
         self.instrument_data.loc[:, "week_option_prefix"] = np.where(
-            self.instrument_data.month_number.astype(float) >= 10,
-            self.instrument_data.month.str[0]
+            self.instrument_data["month_number"].astype(float) >= 10,
+            self.instrument_data["month"].str[0]
             + self.instrument_data["expiry"].dt.strftime("%d").astype(str),
-            self.instrument_data.month_number
+            self.instrument_data["month_number"]
             + self.instrument_data["expiry"].dt.strftime("%d").astype(str),
         )
 
-        self.instrument_data.loc[:, "next_expiry"] = (
-            self.instrument_data.expiry + pd.DateOffset(days=7)
-        )
+        self.instrument_data.loc[:, "next_expiry"] = self.instrument_data[
+            "expiry"
+        ] + pd.DateOffset(days=7)
 
-    @cached(cache=TTLCache(maxsize=1, ttl=2))
+    @cached(cache=TTLCache(maxsize=1, ttl=2))  # type: ignore
     def cached_orders(self) -> pl.DataFrame:
         return self.orders()
 
-    @cached(cache=TTLCache(maxsize=1, ttl=2))
+    @cached(cache=TTLCache(maxsize=1, ttl=2))  # type: ignore
     def cached_positions(self) -> pl.DataFrame:
         return self.positions()
 
     def execute_order(
         self,
-        tradingsymbol,
-        exchange,
-        quantity,
-        order_type,
-        transaction_type,
-        stoploss,
-        tag,
-        product,
-        price,
+        tradingsymbol: str,
+        exchange: ExchangeType,
+        quantity: int,
+        order_type: OrderTypeType,
+        transaction_type: TransactionType,
+        stoploss: float | None,
+        tag: str,
+        product: ProductType,
+        price: float,
     ):
         upper_circuit = None
         trade_price = copy.deepcopy(price)
@@ -396,6 +398,7 @@ class Broker:
                         raise Exception("{} not supported for trading".format(exchange))
 
                     sl_price = self.round_to_tick(price)
+
                 else:
                     raise Exception(
                         "Invalid transaction_type {}".format(transaction_type)
@@ -427,7 +430,7 @@ class Broker:
                     )
 
             if order_type == "MARKET":
-                trade_price = 0
+                trade_price: float = 0
 
             response = self.place_order(
                 tradingsymbol=tradingsymbol,
@@ -462,7 +465,7 @@ class Broker:
     def get_exchange(self, exchange):
         return exchange
 
-    def live_data(self, exchange, tradingsymbol):
+    def live_data(self, exchange: ExchangeType, tradingsymbol: str):
         return {
             "ltp": self.ltp(exchange, tradingsymbol),
             "upper_circuit": None,
@@ -472,7 +475,13 @@ class Broker:
     def basket_margin(self, basket_orders) -> Dict[str, Any]:
         raise FeatureNotSupported("Margin calculator not supported by broker")
 
-    def verify_rms_square_off(self, stoploss, target, keep_hedges=False, ticks=1):
+    def verify_rms_square_off(
+        self,
+        stoploss: float | None,
+        target: float | None,
+        keep_hedges: bool = False,
+        ticks: int = 1,
+    ):
         positions = self.positions()
         pnl = positions["pnl"].sum()
 
@@ -514,31 +523,37 @@ class Broker:
     def get_product(self, product):
         return product
 
-    def get_lot_size(self, exchange, tradingsymbol):
+    def get_lot_size(self, exchange: ExchangeType, tradingsymbol: str):
         tradingsymbol = self.get_symbol(tradingsymbol, exchange=exchange)
-        exchange = self.get_exchange(exchange)
-        if exchange == "BSE" or exchange == "NSE":
+        broker_exchange = self.get_exchange(exchange)
+        if broker_exchange == "BSE" or broker_exchange == "NSE":
             return 1
         try:
             return int(
-                self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["lot_size"]
+                self.symbol_data["{}:{}".format(broker_exchange, tradingsymbol)][
+                    "lot_size"
+                ]
             )
         except Exception as e:
             logger.error(
-                f"[GET_LOT_SIZE] unable to get lot size for {exchange} {tradingsymbol}"
+                f"[GET_LOT_SIZE] unable to get lot size for {broker_exchange} {tradingsymbol}"
             )
             raise e
 
-    def filter_orders(self, orders, tag=None, status=None):
+    def filter_orders(
+        self, orders: pd.DataFrame, tag: str | None = None, status: str | None = None
+    ):
         if tag:
-            orders = orders[orders.tag == tag]
+            orders = orders[orders["tag"] == tag]
 
         if status:
-            orders = orders[orders.status == status]
+            orders = orders[orders["status"] == status]
 
         return orders
 
-    def option_symbol(self, underlying_symbol, expiry_date, strike_price, type):
+    def option_symbol(
+        self, underlying_symbol: str, expiry_date, strike_price: float, type
+    ):
         option_symbol = MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP[
             underlying_symbol
         ]
@@ -567,10 +582,10 @@ class Broker:
 
     def exit_all_trigger_orders(
         self,
-        tag="ALL",
+        tag: str = "ALL",
         symbol_contains=None,
         order_timestamp=None,
-        modify_sleep_time=10,
+        modify_sleep_time: float = 10,
     ):
         stoploss_orders = self.orders()
         stoploss_orders = stoploss_orders.filter(pl.col("status") == "TRIGGER PENDING")
@@ -1210,7 +1225,7 @@ class Broker:
         """
         raise NotImplementedError
 
-    def modify_order(self, order_to_modify: ModifyOrderRequest) -> str:
+    def modify_order(self, order_to_modify) -> str:
         """Modifies Existing Order place on exchange
 
         Args:
@@ -1235,7 +1250,7 @@ class Broker:
         product: ProductType,
         price: float,
         trigger_price: float | None = None,
-    ) -> str:
+    ) -> str | None:
         """Function for Place Order to exchange
 
         Args:

{quantplay-2.0.32 → quantplay-2.0.33}/quantplay/broker/kite_utils.py

@@ -73,8 +73,6 @@ class KiteUtils:
             pyotp.TOTP(totp).now()
             driver = Selenium().get_browser()
 
-            # TODO api should be fetched from configuration
-
             kite_url = "https://kite.trade/connect/login?api_key={}&v=3".format(api_key)
             print("Kite Url {}".format(kite_url))