quantplay 2.0.39__tar.gz → 2.0.41__tar.gz

{quantplay-2.0.39 → quantplay-2.0.41}/PKG-INFO

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

{quantplay-2.0.39 → quantplay-2.0.41}/pyproject.toml

@@ -5,7 +5,7 @@ line-length = 90
 line-length = 90
 
 [tool.pyright]
-typeCheckingMode = "standard"
+typeCheckingMode = "strict"
 pythonVersion = "3.12"
 venvPath = "."
 venv = ".venv"

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/aliceblue.py

@@ -314,8 +314,9 @@ class Aliceblue(Broker):
         data: ModifyOrderRequest = {
             "order_id": order_id,
             "price": price,
-            "order_type": order_type,
         }
+        if trigger_price is not None:
+            data["order_type"] = order_type
 
         if trigger_price is not None and trigger_price > 0:
             data["trigger_price"] = trigger_price
@@ -403,7 +404,7 @@ class Aliceblue(Broker):
         if not isinstance(positions_response, list):
             return pl.DataFrame(schema=self.positions_schema)
 
-        positions_df = pl.from_dicts(positions_response)
+        positions_df = pl.from_dicts(positions_response)  # type: ignore
 
         positions_df = positions_df.with_columns(
             (
@@ -454,13 +455,16 @@ class Aliceblue(Broker):
             self.positions_schema
         )
 
+    def get_exchange(self, exchange: ExchangeType) -> Any:
+        return exchange
+
     def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
         orders_response = self.invoke_aliceblue_api(self.alice.order_data)
 
         if not isinstance(orders_response, list):
             return pl.DataFrame(schema=self.orders_schema)
 
-        if len(orders_response) == 0:
+        if len(orders_response) == 0:  # type: ignore
             return pl.DataFrame(schema=self.orders_schema)
 
         orders_df = pl.DataFrame(orders_response)

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/angelone.py

@@ -106,6 +106,9 @@ class AngelOne(Broker):
         if load_instrument:
             self.load_instrument()
 
+    def get_exchange(self, exchange: ExchangeType) -> Any:
+        return exchange
+
     def load_instrument(self, file_name: str | None = None) -> None:
         try:
             instrument_data_instance = InstrumentData.get_instance()
@@ -282,7 +285,7 @@ class AngelOne(Broker):
 
             Constants.logger.info(f"Modifying order [{order_id}] params [{order_params}]")
             response = self.invoke_angelone_api(
-                self.wrapper.modifyOrder,
+                self.wrapper.modifyOrder,  # type: ignore
                 orderparams=order_params,
             )
             Constants.logger.info(f"[MODIFY_ORDER_RESPONSE] {response}")

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/dhan.py

@@ -1,17 +1,14 @@
 import codecs
 import pickle
 import traceback
-from datetime import datetime, timedelta
-from typing import Any, Callable, Dict, Hashable, List
+from typing import Any, Dict, Hashable, List
 
-import pandas as pd
 import polars as pl
 from kiteconnect import KiteConnect, KiteTicker  # type: ignore
 from kiteconnect.exceptions import TokenException  # type: ignore
 from retrying import retry  # type: ignore
 
 from quantplay.broker.generics.broker import Broker
-from quantplay.broker.kite_utils import KiteUtils
 from quantplay.exception.exceptions import (
     InvalidArgumentException,
     QuantplayOrderPlacementException,
@@ -21,19 +18,16 @@ from quantplay.exception.exceptions import (
 from quantplay.exception.exceptions import TokenException as QuantplayTokenException
 from quantplay.model.broker import (
     ExchangeType,
-    ModifyOrderRequest,
-    UserBrokerProfileResponse,
 )
 from quantplay.model.generics import (
     DhanTypes,
-    NorenTypes,
     OrderTypeType,
     ProductType,
     TransactionType,
 )
 from quantplay.utils.constant import Constants, OrderType
 from quantplay.utils.pickle_utils import InstrumentData, PickleUtils
-from dhanhq import dhanhq
+from dhanhq import dhanhq  # type:ignore
 
 
 class Dhan(Broker):
@@ -244,7 +238,7 @@ class Dhan(Broker):
             Constants.logger.info(
                 f"[PLACING_ORDER] {tradingsymbol} {exchange} {quantity} {tag}"
             )
-            order_id = self.dhan.place_order(
+            order_id: str = self.dhan.place_order(  # type:ignore
                 security_id="1333",  # hdfcbank
                 exchange_segment=self.get_exchange_segment(exchange),
                 transaction_type=transaction_type,
@@ -254,7 +248,7 @@ class Dhan(Broker):
                 price=price,
             )
 
-            return order_id
+            return order_id  # type:ignore
         except Exception as e:
             raise QuantplayOrderPlacementException(str(e))
 
@@ -300,7 +294,7 @@ class Dhan(Broker):
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
         positions = self.dhan_w.get_positions()
 
-        positions_df = pl.DataFrame(positions.get("data", {}))
+        positions_df = pl.DataFrame(positions.get("data", {}))  # type:ignore
 
         if len(positions_df) == 0:
             return pl.DataFrame(schema=self.positions_schema)

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/five_paisa.py

@@ -1,7 +1,7 @@
 import codecs
 import pickle
 import traceback
-from typing import Dict
+from typing import Any, Dict
 
 import polars as pl
 import pyotp
@@ -17,7 +17,7 @@ from quantplay.exception.exceptions import (
     TokenException,
     retry_exception,
 )
-from quantplay.model.broker import UserBrokerProfileResponse
+from quantplay.model.broker import ModifyOrderRequest, UserBrokerProfileResponse
 from quantplay.model.generics import (
     ExchangeType,
     OrderTypeType,
@@ -98,6 +98,9 @@ class FivePaisa(Broker):
             self.load_instrument()
         super(FivePaisa, self).__init__()
 
+    def get_exchange(self, exchange: ExchangeType) -> Any:
+        return exchange
+
     def set_client(self, serialized_client: str):
         self.client: FivePaisaClient = pickle.loads(
             codecs.decode(serialized_client.encode(), "base64")
@@ -150,7 +153,7 @@ class FivePaisa(Broker):
     )
     def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
         tradingsymbol = self.get_symbol(tradingsymbol, exchange)
-        exchange_name = self.get_exchange(exchange)
+        exchange_name = self.get_exchange_name(exchange)
         exchange_type = self.get_exchange_type(exchange)
         token = self.symbol_attribute(exchange, tradingsymbol, "token")
         req_list = [
@@ -448,7 +451,10 @@ class FivePaisa(Broker):
 
         return False
 
-    def get_exchange(self, exchange):
+    def get_order_type(self, order_type: OrderTypeType) -> Any:
+        return order_type
+
+    def get_exchange_name(self, exchange: ExchangeType):
         return exchange[0]
 
     @staticmethod
@@ -490,7 +496,7 @@ class FivePaisa(Broker):
             )
             response = self.client.place_order(
                 OrderType=transaction_type[0],
-                Exchange=self.get_exchange(exchange),
+                Exchange=self.get_exchange_name(exchange),
                 ExchangeType=FivePaisa.get_exchange_type(exchange),
                 ScripCode=token,
                 Qty=quantity,
@@ -551,6 +557,12 @@ class FivePaisa(Broker):
         }
         return response
 
+    def cancel_order(self, order_id: str, variety: str | None = None) -> None:
+        raise NotImplementedError("Cancel Order Not Implementd")
+
+    def modify_order(self, order: ModifyOrderRequest) -> str:
+        raise NotImplementedError("Cancel Order Not Implementd")
+
     def get_quantplay_product(self, exchange: ExchangeType, product: ProductType):
         product_map: Dict[str, ProductType] = {"D": "CNC", "I": "MIS"}
         if product in product_map:

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/generics/broker.py

@@ -16,7 +16,7 @@ from queue import Queue
 from threading import Lock
 from typing import Any, Dict, List, Literal, Type
 
-import pandas as pd
+import pandas as pd  # type:ignore
 import polars as pl
 import requests
 from cachetools import TTLCache, cached
@@ -24,7 +24,6 @@ from cachetools import TTLCache, cached
 from quantplay.exception.exceptions import (
     FeatureNotSupported,
     InvalidArgumentException,
-    QuantplayOrderPlacementException,
     StaleDataFound,
 )
 from quantplay.model.broker import (
@@ -32,7 +31,12 @@ from quantplay.model.broker import (
     ModifyOrderRequest,
     UserBrokerProfileResponse,
 )
-from quantplay.model.generics import ProductType, TransactionType, OrderTypeType
+from quantplay.model.generics import (
+    ProductType,
+    QuantplayOrder,
+    TransactionType,
+    OrderTypeType,
+)
 from quantplay.model.instrument_data import InstrumentDataType
 from quantplay.model.order_event import OrderUpdateEvent
 from quantplay.utils.constant import Constants
@@ -218,104 +222,6 @@ class Broker(ABC):
     def cached_positions(self) -> pl.DataFrame:
         return self.positions()
 
-    def execute_order(
-        self,
-        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)
-        if price is None:
-            live_data = self.live_data(exchange=exchange, tradingsymbol=tradingsymbol)
-            price = live_data["ltp"]
-            upper_circuit = live_data["upper_circuit"]
-            trade_price = copy.deepcopy(price)
-        try:
-            if stoploss is not None:
-                if transaction_type == "SELL":
-                    sl_transaction_type = "BUY"
-                    sl_trigger_price = self.round_to_tick(price * (1 + stoploss))
-
-                    if exchange == "NFO":
-                        price = sl_trigger_price * 1.05
-                    elif exchange == "NSE":
-                        price = sl_trigger_price * 1.01
-                    else:
-                        raise Exception("{} not supported for trading".format(exchange))
-
-                    sl_price = self.round_to_tick(price)
-                elif transaction_type == "BUY":
-                    sl_transaction_type = "SELL"
-                    sl_trigger_price = self.round_to_tick(price * (1 - stoploss))
-
-                    if exchange == self.nfo_exchange:
-                        price = sl_trigger_price * 0.95
-                    elif exchange == "NSE":
-                        price = sl_trigger_price * 0.99
-                    else:
-                        raise Exception("{} not supported for trading".format(exchange))
-
-                    sl_price = self.round_to_tick(price)
-
-                else:
-                    raise Exception(
-                        "Invalid transaction_type {}".format(transaction_type)
-                    )
-
-                if upper_circuit is not None and sl_price > upper_circuit:
-                    raise Exception(
-                        f"[PRICE_BREACHED] {sl_price} is above upper circuit price [{upper_circuit}]"
-                    )
-
-                stoploss_order_id = self.place_order(
-                    tradingsymbol=tradingsymbol,
-                    exchange=exchange,
-                    quantity=quantity,
-                    order_type=self.order_type_sl,  # type: ignore
-                    transaction_type=sl_transaction_type,
-                    tag=tag,
-                    product=product,
-                    price=sl_price,
-                    trigger_price=sl_trigger_price,
-                )
-
-                if stoploss_order_id is None:
-                    Constants.logger.error(
-                        "[ORDER_REJECTED] tradingsymbol {}".format(tradingsymbol)
-                    )
-                    raise QuantplayOrderPlacementException(
-                        "Order reject for {}".format(tradingsymbol)
-                    )
-
-            if order_type == "MARKET":
-                trade_price: float = 0
-
-            response = self.place_order(
-                tradingsymbol=tradingsymbol,
-                exchange=exchange,
-                quantity=quantity,
-                order_type=order_type,
-                transaction_type=transaction_type,
-                tag=tag,
-                product=product,
-                price=trade_price,
-            )
-            return response
-        except Exception as e:
-            raise e
-
-    """
-            Input  : quantplay symbol
-            Output : broker symbol
-        """
-
     def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
         return symbol
 
@@ -324,12 +230,6 @@ class Broker(ABC):
         Output : broker exchange
     """
 
-    def get_order_type(self, order_type):
-        return order_type
-
-    def get_exchange(self, exchange):
-        return exchange
-
     def live_data(self, exchange: ExchangeType, tradingsymbol: str):
         return {
             "ltp": self.ltp(exchange, tradingsymbol),
@@ -337,7 +237,7 @@ class Broker(ABC):
             "lower_circuit": None,
         }
 
-    def basket_margin(self, basket_orders) -> Dict[str, Any]:
+    def basket_margin(self, basket_orders: List[Any]) -> Dict[str, Any]:
         raise FeatureNotSupported("Margin calculator not supported by broker")
 
     def verify_rms_square_off(
@@ -387,9 +287,6 @@ class Broker(ABC):
 
         return quantity_in_lots * lot_size
 
-    def get_product(self, product):
-        return product
-
     def get_lot_size(self, exchange: ExchangeType, tradingsymbol: str):
         tradingsymbol = self.get_symbol(tradingsymbol, exchange=exchange)
         broker_exchange = self.get_exchange(exchange)
@@ -855,16 +752,6 @@ class Broker(ABC):
 
         return orders_to_close
 
-    def add_ltp(self, orders):
-        orders.loc[:, "exchange_symbol"] = orders.exchange + ":" + orders.tradingsymbol
-
-        all_symbols = list(orders.exchange_symbol.unique())
-        symbol_ltp = {}
-        for exchange_symbol in all_symbols:
-            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)
-
     def modify_price(
         self,
         order_id: str,
@@ -889,7 +776,7 @@ class Broker(ABC):
             return "BUY"
         raise Exception(f"unknown transaction type [{transaction_type}]")
 
-    def place_large_orders(self, orders: List) -> List[str | None]:
+    def place_large_orders(self, orders: List[QuantplayOrder]) -> List[str | None]:
         order_ids: List[str | None] = []
         orders = sorted(orders, key=lambda d: d["transaction_type"])
         for order in orders:
@@ -943,7 +830,7 @@ class Broker(ABC):
 
         new_trading_symbol = f"{underlying}{expiry}{new_strike}{instrument_type}"
 
-        orders = [
+        orders: List[QuantplayOrder] = [
             {
                 "tradingsymbol": tradingsymbol,
                 "exchange": exchange,
@@ -1157,3 +1044,12 @@ class Broker(ABC):
     def margins(self) -> Dict[str, float]:
         """Returns User Margin Summary"""
         ...
+
+    @abstractmethod
+    def get_order_type(self, order_type: OrderTypeType) -> ...: ...
+
+    @abstractmethod
+    def get_exchange(self, exchange: ExchangeType) -> ...: ...
+
+    @abstractmethod
+    def get_product(self, product: ProductType) -> ...: ...

quantplay-2.0.41/quantplay/broker/generics/broker_factory.py

@@ -0,0 +1,222 @@
+import os
+import traceback
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from quantplay.broker.aliceblue import Aliceblue
+from quantplay.broker.angelone import AngelOne
+
+from quantplay.broker.five_paisa import FivePaisa
+from quantplay.broker.flattrade import FlatTrade
+from quantplay.broker.iifl_xts import IIFL as IIFL_XTS
+from quantplay.broker.motilal import Motilal
+from quantplay.broker.shoonya import FinvAsia
+from quantplay.broker.upstox import Upstox
+from quantplay.broker.zerodha import Zerodha
+from quantplay.exception.exceptions import InvalidArgumentException
+
+from quantplay.utils.pickle_utils import PickleUtils
+from quantplay.utils.caching import InstrumentCache
+
+BrokerType = (
+    Aliceblue
+    | AngelOne
+    | FlatTrade
+    | Motilal
+    | FinvAsia
+    | Upstox
+    | Zerodha
+    | IIFL_XTS
+    | FivePaisa
+)
+
+instrument_cache = InstrumentCache()
+
+
+@dataclass
+class Broker:
+    ZERODHA = "Zerodha"
+    UPSTOX = "Upstox"
+    ALICEBLUE = "Aliceblue"
+    FIVEPAISA_OPENAPI = "5Paisa_OpenAPI"
+    FINVASIA = "Finvasia"
+    FLATTRADE = "Flattrade"
+    IIFL_XTS = "IIFL_XTS"
+    MOTILAL = "Motilal"
+    ANGELONE = "Angelone"
+
+
+class BrokerFactory:
+    broker_instruments_map = {
+        Broker.ZERODHA: "zerodha_instruments",
+        Broker.FINVASIA: "shoonya_instruments",
+        Broker.FLATTRADE: "shoonya_instruments",
+        Broker.IIFL_XTS: "xts_instruments",
+        Broker.MOTILAL: "motilal_instruments",
+        Broker.ANGELONE: "angelone_instruments",
+        Broker.ALICEBLUE: "aliceblue_instruments",
+        Broker.UPSTOX: "upstox_instruments",
+        Broker.FIVEPAISA_OPENAPI: "5paisa_instruments",
+    }
+
+    def __init__(self):
+        self.client_broker_data: Dict[str, BrokerType] = {}
+
+    def get_broker_key(self, username: str, broker_name: str) -> str:
+        return "{}:{}".format(username, broker_name)
+
+    def set_broker_instruments(self, broker_name: str, broker: BrokerType) -> None:
+        symbol_data_key = f"{broker_name}_instruments"
+        quantplay_symbol_key = f"{broker_name}_qplay_symbols"
+        broker_symbol_key = f"{broker_name}_broker_symbols"
+
+        symbol_data = instrument_cache.get(symbol_data_key)
+        quantplay_symbol_map = instrument_cache.get(quantplay_symbol_key)
+        broker_symbol_map = instrument_cache.get(broker_symbol_key)
+
+        if symbol_data is not None:
+            broker.symbol_data = symbol_data
+
+            if broker_name != "Zerodha":
+                if quantplay_symbol_map is not None and broker_symbol_map is not None:
+                    broker.quantplay_symbol_map = quantplay_symbol_map
+                    broker.broker_symbol_map = broker_symbol_map
+
+                else:
+                    broker.initialize_broker_symbol_map()
+                    instrument_cache.set(
+                        quantplay_symbol_key, broker.quantplay_symbol_map
+                    )
+                    instrument_cache.set(broker_symbol_key, broker.broker_symbol_map)
+
+            return
+
+        try:
+            symbol_data = PickleUtils.load_data(
+                BrokerFactory.broker_instruments_map[broker_name]
+            )
+            broker.symbol_data = symbol_data
+
+            if broker_name != "Zerodha":
+                broker.initialize_broker_symbol_map()
+                instrument_cache.set(quantplay_symbol_key, broker.quantplay_symbol_map)
+
+            instrument_cache.set(symbol_data_key, symbol_data)
+
+        except Exception:
+            traceback.print_exc()
+
+            if broker_name != "Zerodha":
+                broker.load_instrument(BrokerFactory.broker_instruments_map[broker_name])
+            else:
+                broker.initialize_symbol_data()
+
+    def store_broker_client(
+        self, broker_info: Dict[str, Any], load_instrument: bool = True
+    ) -> None:
+        username = broker_info["username"]
+        nickname = broker_info["nickname"]
+
+        broker_key = self.get_broker_key(username, nickname)
+
+        broker_data = broker_info["broker_data"]
+        broker = broker_info["broker"]
+
+        broker_client: BrokerType | None = None
+
+        if broker == "Motilal":
+            motial_headers = broker_data["headers"]
+            broker_client = Motilal(
+                headers=motial_headers, load_instrument=load_instrument
+            )
+
+        elif broker == "Zerodha":
+            broker_client = Zerodha(
+                wrapper=broker_data["zerodha_wrapper"],
+                load_instrument=load_instrument,
+            )
+
+        elif broker == "Angelone":
+            broker_client = AngelOne(
+                user_id=broker_data["user_id"],
+                api_key=broker_data["api_key"],
+                access_token=broker_data["access_token"],
+                refresh_token=broker_data["refresh_token"],
+                feed_token=broker_data["feed_token"],
+                load_instrument=load_instrument,
+            )
+
+        elif broker == Broker.ALICEBLUE:
+            broker_client = Aliceblue(client=broker_data["client"])
+
+        elif broker == Broker.UPSTOX:
+            broker_client = Upstox(
+                access_token=broker_data["access_token"],
+                user_id=broker_data["user_id"],
+            )
+
+        elif broker == Broker.FINVASIA:
+            finvasia_data = broker_data
+            broker_client = FinvAsia(
+                order_updates=None,
+                user_id=finvasia_data["user_id"],
+                password=finvasia_data["password"],
+                user_token=finvasia_data["user_token"],
+                load_instrument=load_instrument,
+            )
+
+        elif broker == Broker.FLATTRADE:
+            flattrade_data = broker_data
+            broker_client = FlatTrade(
+                order_updates=None,
+                user_id=flattrade_data["user_id"],
+                password=flattrade_data["password"],
+                user_token=flattrade_data["user_token"],
+                load_instrument=load_instrument,
+            )
+
+        elif broker == Broker.FIVEPAISA_OPENAPI:
+            broker_client = FivePaisa(
+                client=broker_data["client"],
+                load_instrument=load_instrument,
+            )
+
+            self.client_broker_data[broker_key] = broker_client
+
+        elif broker == Broker.IIFL_XTS:
+            iifl_xts_data = broker_data
+            broker_client = IIFL_XTS(
+                wrapper=broker_data["wrapper"],
+                md_wrapper=broker_data["md_wrapper"],
+                client_id=iifl_xts_data["user_id"],
+                load_instrument=load_instrument,
+            )
+
+        else:
+            raise InvalidArgumentException(f"Broker {broker} not supported")
+
+        self.client_broker_data[broker_key] = broker_client
+        self.set_broker_instruments(broker_name=broker, broker=broker_client)
+
+    def get_broker_client(self, broker_info: Dict[str, Any]) -> BrokerType:
+        username = broker_info["username"]
+        nickname = broker_info["nickname"]
+
+        broker_key = self.get_broker_key(username, nickname)
+
+        if broker_key in self.client_broker_data:
+            return self.client_broker_data[broker_key]
+
+        self.store_broker_client(broker_info, load_instrument=False)
+
+        if broker_key in self.client_broker_data:
+            return self.client_broker_data[broker_key]
+        else:
+            raise InvalidArgumentException("Invalid broker API configuration")
+
+    def clear_instrument_cache(self, broker: str) -> None:
+        symbol_data_key = f"{broker}_instruments"
+        instrument_cache.delete(symbol_data_key)
+
+        file_name = self.broker_instruments_map[broker]
+        os.system(f"rm /tmp/{file_name}*")

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/motilal.py

@@ -4,10 +4,9 @@ from queue import Queue
 from typing import Any, Dict
 import requests
 import json
-import pandas as pd
 import polars as pl
 
-from quantplay.model.broker import ModifyOrderRequest, UserBrokerProfileResponse
+from quantplay.model.broker import UserBrokerProfileResponse
 from quantplay.model.generics import (
     ExchangeType,
     OrderTypeType,
@@ -153,13 +152,6 @@ class Motilal(Broker):
         self.nfo_exchange = "NSEFO"
         self.exchange_code_map = {"NFO": "NSEFO", "CDS": "NSECD", "BFO": "BSEFO"}
 
-    def load_file_by_url(self, exchange):
-        data_url = "https://openapi.motilaloswal.com/getscripmastercsv?name={}".format(
-            exchange
-        )
-        df = pd.read_csv(data_url)  # type: ignore
-        self.instrument_data_by_exchange[exchange] = df
-
     def load_instrument(self, file_name: str | None = None) -> None:
         try:
             self.symbol_data = InstrumentData.get_instance().load_data(  # type: ignore
@@ -181,6 +173,12 @@ class Motilal(Broker):
 
         return self.quantplay_symbol_map[symbol]
 
+    def get_motilal_symbol(self, symbol: str):
+        if symbol not in self.quantplay_symbol_map:
+            return symbol
+
+        return self.quantplay_symbol_map[symbol]
+
     def get_order_type(self, order_type: OrderTypeType):
         if order_type == OrderType.sl:
             return "STOPLOSS"
@@ -198,9 +196,9 @@ class Motilal(Broker):
             return "DELIVERY"
         elif product == "NRML":
             return "NORMAL"
-        elif product == "DELIVERY":
-            return "DELIVERY"
-        return "NORMAL"
+        elif product == "MIS":
+            return "NORMAL"
+        return product
 
     def place_order_quantity(
         self, quantity: int, tradingsymbol: str, exchange: ExchangeType
@@ -210,8 +208,8 @@ class Motilal(Broker):
 
         return quantity_in_lots
 
-    def get_lot_size(self, exchange, tradingsymbol: str):
-        tradingsymbol = self.get_symbol(tradingsymbol, exchange=exchange)
+    def get_lot_size(self, exchange: str, tradingsymbol: str):
+        tradingsymbol = self.get_symbol(tradingsymbol)
         if exchange == "NSEFO":
             exchange = "NFO"
         elif exchange == "BSEFO":

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/noren.py

@@ -303,6 +303,9 @@ class Noren(Broker):
 
         return data
 
+    def get_exchange(self, exchange: ExchangeType) -> Any:
+        return exchange
+
     @retry(
         wait_exponential_multiplier=3000,
         wait_exponential_max=10000,
@@ -312,8 +315,6 @@ class Noren(Broker):
         order_id = order["order_id"]
         existing_details = self.order_history(order_id)
 
-        order["order_type"] = self.get_order_type(order["order_type"])  # type: ignore
-
         if "trigger_price" not in order:
             order["trigger_price"] = None
 
@@ -323,11 +324,13 @@ class Noren(Broker):
         if "quantity" not in order:
             order["quantity"] = int(existing_details["quantity"])
 
+        order["order_type"] = self.get_order_type(order["order_type"])  # type: ignore
+
         try:
             logger.info(f"[MODIFYING_ORDER] {order}")
             response = self.api.modify_order(  # type:ignore
                 orderno=order_id,
-                exchange=existing_details["exchange"],
+                exchange=existing_details["exchange"],  # type: ignore
                 tradingsymbol=existing_details["tradingsymbol"],
                 newprice_type=order["order_type"],
                 newquantity=order["quantity"],

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/upstox.py

@@ -115,7 +115,7 @@ class Upstox(Broker):
 
         return exchange
 
-    def get_quantplay_exchange(self, exchange) -> ExchangeType:
+    def get_quantplay_exchange(self, exchange: str) -> ExchangeType:
         exchange_map: Dict[str, ExchangeType] = {
             "NSE_FO": "NFO",
             "NSECD": "CDS",
@@ -125,7 +125,7 @@ class Upstox(Broker):
         if exchange in exchange_map:
             return exchange_map[exchange]
 
-        return exchange
+        return exchange  # type: ignore
 
     def get_quantplay_symbol(self, symbol: str):
         return symbol
@@ -133,6 +133,9 @@ class Upstox(Broker):
     def get_lot_size(self, exchange: ExchangeType, tradingsymbol: str):
         return int(self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["lot_size"])
 
+    def get_order_type(self, order_type: OrderTypeType) -> Any:
+        return order_type
+
     @retry(
         wait_exponential_multiplier=1000,
         wait_exponential_max=10000,
@@ -158,7 +161,7 @@ class Upstox(Broker):
             self.handle_exception(e)
             Constants.logger.error("Exception when calling MarketQuoteApi->ltp: %s\n" % e)
 
-        return ltp
+        return ltp  # type: ignore
 
     @retry(
         wait_exponential_multiplier=1000,
@@ -216,7 +219,7 @@ class Upstox(Broker):
         product: ProductType,
         price: float,
         trigger_price: float | None = None,
-    ):
+    ) -> str:
         exchange = self.get_quantplay_exchange(exchange)
         try:
             Constants.logger.info(
@@ -297,10 +300,10 @@ class Upstox(Broker):
             profile_data = api_response.data  # type:ignore
 
             response: UserBrokerProfileResponse = {
-                "user_id": profile_data.user_id,
-                "full_name": profile_data.user_name,
-                "exchanges": profile_data.exchanges,
-                "email": profile_data.email,
+                "user_id": profile_data.user_id,  # type: ignore
+                "full_name": profile_data.user_name,  # type: ignore
+                "exchanges": profile_data.exchanges,  # type: ignore
+                "email": profile_data.email,  # type: ignore
             }
             self.email = response["email"]
             self.enabled_exchanges = response["exchanges"]
@@ -370,8 +373,9 @@ class Upstox(Broker):
         try:
             # Get Positions
             api_response = api_instance.get_positions(self.api_version)  # type: ignore
-            positions = [
-                position.to_dict() for position in api_response.data  # type:ignore
+            positions = [  # type:ignore
+                position.to_dict()  # type:ignore
+                for position in api_response.data  # type:ignore
             ]
             positions_df = pl.DataFrame(positions)
         except ApiException as e:
@@ -634,7 +638,7 @@ class Upstox(Broker):
         configuration.access_token = self.access_token
 
         # Get portfolio stream feed authorize
-        response = self.get_portfolio_stream_feed_authorize(
+        response = self.get_portfolio_stream_feed_authorize(  # type: ignore
             self.api_version, configuration
         )
 
@@ -651,13 +655,13 @@ class Upstox(Broker):
 
     def get_portfolio_stream_feed_authorize(
         self, api_version: str, configuration: upstox_client.Configuration
-    ):
+    ) -> Any:
         api_instance = upstox_client.WebsocketApi(upstox_client.ApiClient(configuration))
         api_response = api_instance.get_portfolio_stream_feed_authorize(api_version)  # type: ignore
 
-        return api_response
+        return api_response  # type: ignore
 
-    def get_quantplay_product(self, exchange, product):
+    def get_quantplay_product(self, exchange: ExchangeType, product: str):
         product_map = {"D": "CNC", "I": "MIS"}
 
         if product in product_map:

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/xts.py

@@ -703,14 +703,22 @@ class XTS(Broker):
         trigger_price: float | None = None,
         order_type: OrderTypeType | None = None,
     ):
-        self.modify_order(
-            {
-                "order_id": str(order_id),
-                "price": price,
-                "trigger_price": trigger_price,
-                "order_type": order_type,
-            }
-        )
+        data: ModifyOrderRequest = {
+            "order_id": str(order_id),
+            "price": price,
+            "trigger_price": trigger_price,
+        }
+
+        if order_type is not None:
+            data["order_type"] = order_type
+
+        self.modify_order(data)
+
+    def get_exchange(self, exchange: ExchangeType) -> Any:
+        return exchange
+
+    def get_product(self, product: ProductType) -> Any:
+        return product
 
     def stream_order_updates(self):
         if self.wrapper.token is None:

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/broker/zerodha.py

@@ -197,6 +197,15 @@ class Zerodha(Broker):
     def cancel_order(self, order_id: str, variety: str | None = "regular"):
         self.wrapper.cancel_order(order_id=order_id, variety=variety)  # type: ignore
 
+    def get_exchange(self, exchange: ExchangeType) -> Any:
+        return exchange
+
+    def get_order_type(self, order_type: OrderTypeType) -> Any:
+        return order_type
+
+    def get_product(self, product: ProductType) -> Any:
+        return product
+
     @retry(
         wait_exponential_multiplier=3000,
         wait_exponential_max=10000,

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/model/broker.py

@@ -15,7 +15,7 @@ class ModifyOrderRequest(TypedDict):
     quantity: NotRequired[int]
     exchange: NotRequired[ExchangeType]
     trigger_price: NotRequired[float | None]
-    order_type: NotRequired[OrderTypeType | None]
+    order_type: NotRequired[OrderTypeType]
     price: NotRequired[float]
 
 

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay/model/generics.py

@@ -1,8 +1,6 @@
 from typing import Literal
-from dhanhq import dhanhq
-from typing import Literal, TypedDict
+from typing import TypedDict
 
-from pya3.alicebluepy import Aliceblue
 
 ExchangeType = Literal["NSE", "BSE", "NFO", "BFO", "CDS", "BCD", "MCX"]
 ProductType = Literal["NRML", "MIS", "CNC"]
@@ -33,15 +31,15 @@ class ZerodhaTypes:
 
 
 class AliceblueTypes:
-    ExchangeType = (
-        Aliceblue.EXCHANGE_BCD
-        | Aliceblue.EXCHANGE_BFO
-        | Aliceblue.EXCHANGE_BSE
-        | Aliceblue.EXCHANGE_CDS
-        | Aliceblue.EXCHANGE_MCX
-        | Aliceblue.EXCHANGE_NFO
-        | Aliceblue.EXCHANGE_NSE
-    )
+    ExchangeType = Literal[
+        "NSE",
+        "NFO",
+        "CDS",
+        "BSE",
+        "BFO",
+        "BCD",
+        "MCX",
+    ]
 
 
 class NorenTypes:
@@ -76,3 +74,11 @@ class XTSTypes:
     PositionSqureOffModeType = Literal["DayWise", "NetWise"]
     PositionSquareOffQuantityTypeType = Literal["Percentage", "ExactQty"]
     DayOrNetType = Literal["DAY", "NET"]
+
+
+class QuantplayOrder(TypedDict):
+    exchange: ExchangeType
+    transaction_type: TransactionType
+    tradingsymbol: str
+    quantity: int
+    product: ProductType

quantplay-2.0.41/quantplay/utils/caching.py

@@ -0,0 +1,35 @@
+from threading import Event, Thread
+from time import sleep
+from typing import Any, Dict, Hashable
+
+
+class InstrumentCache:
+    def __init__(self) -> None:
+        self.cache: Dict[Hashable, Any] = {}
+        self.ttl = 300
+
+        self.stop_event = Event()
+        self.stop_event.set()
+
+        clear_thread = Thread(target=self.auto_clear, daemon=True)
+        clear_thread.start()
+
+    def __del__(self) -> None:
+        self.stop_event.clear()
+
+    def set(self, key: str, data: Any) -> None:
+        self.cache[key] = data
+
+    def get(self, key: str) -> Any | None:
+        return self.cache.get(key, None)
+
+    def delete(self, key: str) -> None:
+        del self.cache[key]
+
+    def clear(self) -> None:
+        self.cache = {}
+
+    def auto_clear(self) -> None:
+        while self.stop_event.is_set():
+            sleep(self.ttl)
+            self.clear()

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.0.39 → quantplay-2.0.41}/quantplay.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ quantplay/broker/ft_utils/flattrade_utils.py
 quantplay/broker/ft_utils/ft_noren.py
 quantplay/broker/generics/__init__.py
 quantplay/broker/generics/broker.py
+quantplay/broker/generics/broker_factory.py
 quantplay/broker/uplink/__init__.py
 quantplay/broker/uplink/uplink_utils.py
 quantplay/broker/xts_utils/Connect.py
@@ -45,6 +46,7 @@ quantplay/model/generics.py
 quantplay/model/instrument_data.py
 quantplay/model/order_event.py
 quantplay/utils/__init__.py
+quantplay/utils/caching.py
 quantplay/utils/constant.py
 quantplay/utils/exchange.py
 quantplay/utils/number_utils.py

{quantplay-2.0.39 → quantplay-2.0.41}/setup.py

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