quantplay 2.0.2__tar.gz → 2.0.3__tar.gz

{quantplay-2.0.2 → quantplay-2.0.3}/PKG-INFO

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

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/aliceblue.py

@@ -1,14 +1,12 @@
 import traceback
 from typing import Callable, Dict, Literal
 
-import pandas as pd
 import polars as pl
 from pya3 import Aliceblue as Alice
 from pya3 import OrderType as AliceOrderType
 from pya3 import ProductType
 from pya3 import TransactionType
 from retrying import retry
-import numpy as np
 import pickle
 import copy
 import codecs
@@ -24,7 +22,7 @@ from quantplay.exception.exceptions import (
 )
 
 from quantplay.exception.exceptions import TokenException as QuantplayTokenException
-from quantplay.utils.constant import Constants, OrderType, OrderStatus, timeit
+from quantplay.utils.constant import Constants, OrderType, timeit
 from quantplay.utils.pickle_utils import InstrumentData
 
 logger = Constants.logger
@@ -55,6 +53,7 @@ class Aliceblue(Broker):
                     api_key=api_key,
                 )
                 response = self.alice.get_session_id()
+
                 if "sessionID" not in response or response["sessionID"] is None:
                     if "emsg" in response:
                         if response["emsg"].lower() == "invalid input":
@@ -248,14 +247,14 @@ class Aliceblue(Broker):
             if "trigger_price" in data and data["trigger_price"] is not None:
                 trigger_price = float(data["trigger_price"])
 
-            response = self.alice.modify_order(
+            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
+                trigger_price=trigger_price,  # type: ignore
                 quantity=quantity,
             )
             logger.info("[MODIFY_ORDER_RESPONSE] [{order_id}]  response [{response}]")
@@ -277,7 +276,7 @@ class Aliceblue(Broker):
         else:
             data["trigger_price"] = None
 
-        self.modify_order(data)  # type:ignore
+        self.modify_order(data)  # type: ignore
 
     def cancel_order(self, order_id: str) -> None:
         self.invoke_aliceblue_api(self.alice.cancel_order, nestordernmbr=order_id)

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/angelone.py

@@ -109,7 +109,7 @@ class AngelOne(Broker):
             raise TokenException(f"{self.user_id}: Invalid Token")
 
     @timeit(MetricName="Angelone:load_instrument")
-    def load_instrument(self, file_name=None):
+    def load_instrument(self, file_name: str | None = None) -> None:
         try:
             instrument_data_instance = InstrumentData.get_instance()
             if instrument_data_instance is not None:
@@ -170,7 +170,7 @@ class AngelOne(Broker):
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
     )
-    def get_ltp(self, exchange=None, tradingsymbol=None):
+    def get_ltp(self, exchange=None, tradingsymbol=None) -> float:
         if tradingsymbol in MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP:
             tradingsymbol = MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP[
                 tradingsymbol
@@ -584,10 +584,6 @@ class AngelOne(Broker):
         api_margins = api_margins["data"]
 
         try:
-            collateral = 0
-            if "collateral" in api_margins:
-                collateral = float(api_margins["collateral"])
-
             margins = {
                 "margin_used": float(api_margins["net"]),
                 "margin_available": float(api_margins["net"]),

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/five_paisa.py

@@ -1,4 +1,3 @@
-import numpy as np
 import polars as pl
 import pyotp
 import pickle
@@ -6,7 +5,6 @@ import codecs
 from py5paisa import FivePaisaClient
 from retrying import retry
 import traceback
-from datetime import datetime
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.exception.exceptions import (
@@ -138,7 +136,7 @@ class FivePaisa(Broker):
         retry_on_exception=retry_exception,
     )
     @timeit(MetricName="5Paisa:get_ltp")
-    def get_ltp(self, exchange, tradingsymbol):
+    def get_ltp(self, exchange, tradingsymbol) -> float:
         tradingsymbol = self.get_symbol(tradingsymbol, exchange)
         exchange_name = self.get_exchange(exchange)
         exchange_type = self.get_exchange_type(exchange)

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/generics/broker.py

@@ -5,7 +5,7 @@ import time
 from collections import defaultdict
 import threading
 from threading import Lock
-from typing import Any, Dict
+from typing import Any, Dict, List, Literal
 
 from cachetools import TTLCache, cached
 import numpy as np
@@ -52,6 +52,10 @@ class Broker:
         self.instrument_id_to_exchange_map = dict()
         self.instrument_id_to_security_type_map = dict()
         self.exchange_symbol_to_instrument_id_map = defaultdict(dict)
+
+        self.quantplay_symbol_map: Dict[str, str] = {}
+        self.broker_symbol_map: Dict[str, str] = {}
+
         self.order_type_sl = "SL"
         self.nfo_exchange = "NFO"
 
@@ -118,6 +122,7 @@ class Broker:
 
         self.trigger_pending_status = "TRIGGER PENDING"
         self.lock = Lock()
+        self.square_off_lock = Lock()
 
     def validate_exchange(self, exchange):
         if exchange not in ["NSE", "NFO", "BFO", "BSE"]:
@@ -137,7 +142,7 @@ class Broker:
             )
             raise StaleDataFound(f"Couldn't find symbol data for [{exchange}:{symbol}]")
 
-    def initialize_symbol_data(self, save_as=None):
+    def initialize_symbol_data(self, save_as: str | None = None) -> None:
         instruments = self.instrument_data
         instruments = instruments.to_dict("records")
         self.symbol_data = {}
@@ -148,7 +153,8 @@ class Broker:
             instrument_data = copy.deepcopy(instrument)
             self.symbol_data["{}:{}".format(exchange, tradingsymbol)] = instrument_data
 
-        PickleUtils.save_data(self.symbol_data, save_as)
+        if save_as:
+            PickleUtils.save_data(self.symbol_data, save_as)
 
     @timeit(MetricName="Broker:initialize_broker_symbol_map")
     def initialize_broker_symbol_map(self):
@@ -163,7 +169,7 @@ class Broker:
             and platform_version[0] == "3"
             and platform_version[1] == "8"
         ):
-            self.quantplay_symbol_map = {}
+            self.quantplay_symbol_map: Dict[str, str] = {}
             for k in self.broker_symbol_map:
                 v = self.broker_symbol_map[k]
                 self.quantplay_symbol_map[v] = k
@@ -171,7 +177,7 @@ class Broker:
             self.quantplay_symbol_map = {v: k for k, v in self.broker_symbol_map.items()}
 
     @timeit(MetricName="Broker:load_instrument")
-    def load_instrument(self, file_name):
+    def load_instrument(self, file_name: str) -> None:
         try:
             instrument_data_instance = InstrumentData.get_instance()
 
@@ -391,7 +397,7 @@ class Broker:
                     tradingsymbol=tradingsymbol,
                     exchange=exchange,
                     quantity=quantity,
-                    order_type=self.order_type_sl,  # type:ignore
+                    order_type=self.order_type_sl,  # type: ignore
                     transaction_type=sl_transaction_type,
                     tag=tag,
                     product=product,
@@ -600,18 +606,25 @@ class Broker:
             stoploss_order["price"] = self.round_to_tick(ltp)
             stoploss_order["trigger_price"] = None
 
-            self.modify_order(stoploss_order)  # type:ignore
+            self.modify_order(stoploss_order)  # type: ignore
             time.sleep(0.1)
 
         self.modify_orders_till_complete(orders_to_close, sleep_time=modify_sleep_time)
         Constants.logger.info("All order have been closed successfully")
 
-    def market_protection_price(self, price, transaction_type, market_protection=0.02):
+    def market_protection_price(
+        self,
+        price: float,
+        transaction_type: Literal["BUY", "SELL"],
+        market_protection: float = 0.02,
+    ) -> float:
         if transaction_type == "BUY":
             price = self.round_to_tick(price * (1 + market_protection))
             return price + 1
+
         elif transaction_type == "SELL":
             return self.round_to_tick(price * (1 - market_protection))
+
         return price
 
     def split_order(self, exchange, tradingsymbol, quantity, max_qty=None):
@@ -883,7 +896,9 @@ class Broker:
             logger.error(f"Couldn't compute freeze quantity for {exchange} {symbol}")
             return 25
 
-    def square_off_by_tag(self, tag, dry_run=True, sleep_time=0.05):
+    def square_off_by_tag(
+        self, tag, dry_run=True, sleep_time=0.05
+    ) -> List[Dict[str, Any]]:
         self.exit_all_trigger_orders(tag=tag)
         orders = self.orders(tag=tag)
 
@@ -906,7 +921,7 @@ class Broker:
             ]
         )
 
-        orders_to_close = []
+        orders_to_close: List[Dict[str, Any]] = []
         exit_orders = exit_orders.filter(pl.col("exit_quantity") != 0)
         positions = exit_orders.to_dicts()
         for position in positions:
@@ -978,13 +993,13 @@ class Broker:
         orders.loc[:, "ltp"] = orders["exchange_symbol"].map(symbol_ltp)
 
     def modify_price(self, order_id, price, trigger_price=None, order_type=None):
-        data = {}  # ignore:type
-
-        data["order_id"] = order_id
-        data["price"] = price
-        data["order_type"] = order_type
-        data["variety"] = "regular"
-        data["trigger_price"] = trigger_price
+        data = {
+            "order_id": order_id,
+            "price": price,
+            "order_type": order_type,
+            "variety": "regular",
+            "trigger_price": trigger_price,
+        }
 
         self.modify_order(data)  # type: ignore
 
@@ -1111,7 +1126,7 @@ class Broker:
                 )
 
                 order["order_type"] = "LIMIT"
-                self.modify_order(order)  # type:ignore
+                self.modify_order(order)  # type: ignore
 
                 time.sleep(0.1)
 

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/motilal.py

@@ -147,9 +147,9 @@ class Motilal(Broker):
         self.instrument_data_by_exchange[exchange] = df
 
     @timeit(MetricName="Motilal:load_instrument")
-    def load_instrument(self, file_name=None):
+    def load_instrument(self, file_name: str | None = None) -> None:
         try:
-            self.symbol_data = InstrumentData.get_instance().load_data(  # type:ignore
+            self.symbol_data = InstrumentData.get_instance().load_data(  # type: ignore
                 "motilal_instruments"
             )
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
@@ -256,7 +256,7 @@ class Motilal(Broker):
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
     )
-    def get_ltp(self, exchange=None, tradingsymbol=None):
+    def get_ltp(self, exchange=None, tradingsymbol=None) -> float:
         tradingsymbol = self.get_symbol(tradingsymbol)
         token = self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["token"]
         exchange = self.get_exchange(exchange)
@@ -273,35 +273,6 @@ class Motilal(Broker):
         Constants.logger.info("[GET_LTP_RESPONSE] response {}".format(response.json()))
         return response.json()["data"]["ltp"] / 100.0
 
-    def get_orders(self, order_status=None, order_type=None):
-        response = (requests.post(self.order_book_url, headers=self.headers)).json()
-        if response["status"] == "ERROR":
-            Constants.logger.info(
-                "Error while fetching order book [{}]".format(response["message"])
-            )
-            raise Exception(response["message"])
-        orders = response["data"]
-
-        if order_status:
-            orders = [a for a in orders if a["orderstatus"] == order_status]
-
-        if order_type:
-            orders = [a for a in orders if a["ordertype"] == order_type]
-
-        return orders
-
-    def get_positions(self):
-        response = (requests.post(self.positions_url, headers=self.headers)).json()
-        if response["status"] == "ERROR":
-            Constants.logger.info(
-                "Error while fetching order book [{}]".format(response["message"])
-            )
-            raise Exception(response["message"])
-
-        positions = response["data"]
-
-        return positions
-
     @timeit(MetricName="Motilal:modify_price")
     def modify_price(self, order_id, price, trigger_price=None, order_type=None):
         orders = self.orders()
@@ -566,8 +537,8 @@ class Motilal(Broker):
     @timeit(MetricName="Motilal:account_summary")
     def account_summary(self):
         response = self.margins()
+        response["pnl"] = float(self.positions()["pnl"].sum())  # type: ignore
 
-        response["pnl"] = self.positions()["pnl"].sum()  # type:ignore
         return response
 
     @timeit(MetricName="Motilal:profile")
@@ -720,7 +691,8 @@ class Motilal(Broker):
             )
             raise Exception(response["message"])
         orders = response["data"]
-        if len(orders) == 0:
+
+        if orders is None or len(orders) == 0:
             return pl.DataFrame(schema=self.orders_schema)
 
         orders_df = pl.DataFrame(orders)

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/noren.py

@@ -39,7 +39,7 @@ class Noren(Broker):
     ):
         super(Noren, self).__init__()
 
-        self.order_updates: Queue = order_updates  # type:ignore
+        self.order_updates: Queue | None = order_updates
 
         if load_instrument:
             self.load_instrument()
@@ -53,9 +53,9 @@ class Noren(Broker):
         self.full_name = response["uname"]
         self.user_token = response["susertoken"]
 
-    def load_instrument(self, file_name=None):
+    def load_instrument(self, file_name: str | None = None) -> None:
         try:
-            self.symbol_data = InstrumentData.get_instance().load_data(  # type:ignore
+            self.symbol_data = InstrumentData.get_instance().load_data(  # type: ignore
                 "shoonya_instruments"
             )
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
@@ -169,7 +169,10 @@ class Noren(Broker):
                 order["status"] = "CANCELLED"
 
             print(f"order feed {order}")
-            self.order_updates.put(order)
+
+            if self.order_updates:
+                self.order_updates.put(order)
+
         except Exception as e:
             logger.error("[ORDER_UPDATE_PROCESSING_FAILED] {}".format(e))
 

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/upstox.py

@@ -62,17 +62,22 @@ class Upstox(Broker):
 
                 self.configuration = upstox_client.Configuration()
                 self.configuration.access_token = self.access_token
-                self.profile()
+
         except Exception as e:
             raise e
 
         self.configuration = upstox_client.Configuration()
         self.configuration.access_token = self.access_token
+        self.api_version = "2.0"
+
+        self.api_client = upstox_client.ApiClient(self.configuration)
+
         if load_instrument:
             self.load_instrument()
+
         super(Upstox, self).__init__()
 
-    def load_instrument(self, file_name=None):
+    def load_instrument(self, file_name: str | None = None) -> None:
         super().load_instrument("upstox_instruments")
 
     def handle_exception(self, e):
@@ -92,6 +97,7 @@ class Upstox(Broker):
             return "D"
         elif product == "MIS":
             return "I"
+
         return product
 
     def get_exchange(self, exchange):
@@ -125,17 +131,15 @@ class Upstox(Broker):
     )
     @timeit(MetricName="Upstox:get_ltp")
     def get_ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:
-        # create an instance of the API class
-        api_instance = upstox_client.MarketQuoteApi(
-            upstox_client.ApiClient(self.configuration)
-        )
-        api_version = "2.0"  # str | API Version Header
+        api_instance = upstox_client.MarketQuoteApi(self.api_client)
 
         ltp = 0
         try:
             symbol_info = self.symbol_data[f"{exchange}:{tradingsymbol}"]
             # Market quotes and instruments - LTP quotes.
-            api_response = api_instance.ltp(symbol_info["instrument_key"], api_version)
+            api_response = api_instance.ltp(
+                symbol_info["instrument_key"], self.api_version
+            )
 
             ltp: float = api_response.data[  # type:ignore
                 f"{self.get_exchange(symbol_info['exchange'])}:{tradingsymbol}"
@@ -158,8 +162,7 @@ class Upstox(Broker):
             or order_to_modify["trigger_price"] is None
         ):
             order_to_modify["trigger_price"] = 0
-        # create an instance of the API class
-        api_instance = upstox_client.OrderApi(upstox_client.ApiClient(self.configuration))
+        api_instance = upstox_client.OrderApi(self.api_client)
         body = upstox_client.ModifyOrderRequest(
             validity="DAY",
             price=order_to_modify["price"],
@@ -167,11 +170,10 @@ class Upstox(Broker):
             order_type=order_to_modify["order_type"],
             trigger_price=order_to_modify["trigger_price"],
         )
-        api_version = "2.0"  # str | API Version Header
 
         try:
             # Modify order
-            api_response = api_instance.modify_order(body, api_version)
+            api_response = api_instance.modify_order(body, self.api_version)
             return api_response.status  # type:ignore
         except ApiException as e:
             Constants.logger.error(
@@ -188,13 +190,11 @@ class Upstox(Broker):
 
     @timeit(MetricName="Upstox:cancel_order")
     def cancel_order(self, order_id: str) -> None:
-        # create an instance of the API class
-        api_instance = upstox_client.OrderApi(upstox_client.ApiClient(self.configuration))
-        api_version = "2.0"  # str | API Version Header
+        api_instance = upstox_client.OrderApi(self.api_client)
 
         try:
             # Cancel order
-            api_response = api_instance.cancel_order(order_id, api_version)
+            api_response = api_instance.cancel_order(order_id, self.api_version)
             return api_response.status  # type:ignore
         except ApiException as e:
             if self.handle_exception(e) == 400:
@@ -224,10 +224,7 @@ class Upstox(Broker):
             if trigger_price is None:
                 trigger_price = 0
 
-            # create an instance of the API class
-            api_instance = upstox_client.OrderApi(
-                upstox_client.ApiClient(self.configuration)
-            )
+            api_instance = upstox_client.OrderApi(self.api_client)
             body = upstox_client.PlaceOrderRequest(
                 quantity=quantity,
                 product=product,
@@ -240,8 +237,8 @@ class Upstox(Broker):
                 trigger_price=trigger_price,
                 is_amo=False,
             )
-            api_version = "2.0"  # str | API Version Header
-            api_response = api_instance.place_order(body, api_version)
+
+            api_response = api_instance.place_order(body, self.api_version)
             return api_response.data.order_id  # type:ignore
         except Exception as e:
             raise QuantplayOrderPlacementException(str(e))
@@ -283,14 +280,12 @@ class Upstox(Broker):
     )
     @timeit(MetricName="Upstox:profile")
     def profile(self) -> UserBrokerProfileResponse:
-        # create an instance of the API class
-        api_instance = upstox_client.UserApi(upstox_client.ApiClient(self.configuration))
-        api_version = "2.0"  # str | API Version Header
+        api_instance = upstox_client.UserApi(self.api_client)
 
         response: UserBrokerProfileResponse = {"user_id": "", "full_name": ""}
         try:
             # Get profile
-            api_response = api_instance.get_profile(api_version)
+            api_response = api_instance.get_profile(self.api_version)
             profile_data = api_response.data  # type:ignore
             response: UserBrokerProfileResponse = {
                 "user_id": profile_data.user_id,
@@ -308,15 +303,12 @@ class Upstox(Broker):
         return response
 
     def holdings(self):
-        api_instance = upstox_client.PortfolioApi(
-            upstox_client.ApiClient(self.configuration)
-        )
+        api_instance = upstox_client.PortfolioApi(self.api_client)
 
-        api_version = "2.0"  # str | API Version Header
         holdings_df = pl.DataFrame()
         try:
             # Get Holdings
-            api_response = api_instance.get_holdings(api_version)
+            api_response = api_instance.get_holdings(self.api_version)
             holdings = [holding.to_dict() for holding in api_response.data]  # type:ignore
             holdings_df = pl.DataFrame(holdings)
         except ApiException as e:
@@ -364,15 +356,12 @@ class Upstox(Broker):
     )
     @timeit(MetricName="Upstox:positions")
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
-        # create an instance of the API class
-        api_instance = upstox_client.PortfolioApi(
-            upstox_client.ApiClient(self.configuration)
-        )
-        api_version = "2.0"  # str | API Version Header
+        api_instance = upstox_client.PortfolioApi(self.api_client)
+
         positions_df = pl.DataFrame(schema=self.positions_schema)
         try:
             # Get Positions
-            api_response = api_instance.get_positions(api_version)
+            api_response = api_instance.get_positions(self.api_version)
             positions = [
                 position.to_dict() for position in api_response.data  # type:ignore
             ]
@@ -462,14 +451,12 @@ class Upstox(Broker):
     )
     @timeit(MetricName="Upstox:orders")
     def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
-        # create an instance of the API class
-        api_instance = upstox_client.OrderApi(upstox_client.ApiClient(self.configuration))
-        api_version = "2.0"  # str | API Version Header
+        api_instance = upstox_client.OrderApi(self.api_client)
 
         orders_df = pl.DataFrame()
         try:
             # Get order book
-            api_response = api_instance.get_order_book(api_version)
+            api_response = api_instance.get_order_book(self.api_version)
             orders = [order.to_dict() for order in api_response.data]  # type:ignore
             orders_df = pl.DataFrame(orders)
         except ApiException as e:
@@ -569,15 +556,17 @@ class Upstox(Broker):
     )
     @timeit(MetricName="Upstox:margins")
     def margins(self):
-        api_instance = upstox_client.UserApi(upstox_client.ApiClient(self.configuration))
-        api_version = "2.0"  # str | API Version Header
+        api_instance = upstox_client.UserApi(self.api_client)
+
         segment = "SEC"  # str |  (optional)
 
         margin_used = 0
         margin_available = 0
         try:
             # Get User Fund And Margin
-            api_response = api_instance.get_user_fund_margin(api_version, segment=segment)
+            api_response = api_instance.get_user_fund_margin(
+                self.api_version, segment=segment
+            )
             margin_used: float = float(
                 api_response.data["equity"].used_margin  # type:ignore
             )
@@ -630,11 +619,13 @@ class Upstox(Broker):
         # Configure OAuth2 access token for authorization: OAUTH2
         configuration = upstox_client.Configuration()
 
-        api_version = "2.0"
+        self.api_version = "2.0"
         configuration.access_token = self.access_token
 
         # Get portfolio stream feed authorize
-        response = self.get_portfolio_stream_feed_authorize(api_version, configuration)
+        response = self.get_portfolio_stream_feed_authorize(
+            self.api_version, configuration
+        )
 
         async with websockets.connect(
             response.data.authorized_redirect_uri,  # type:ignore
@@ -650,6 +641,7 @@ class Upstox(Broker):
     def get_portfolio_stream_feed_authorize(self, api_version, configuration):
         api_instance = upstox_client.WebsocketApi(upstox_client.ApiClient(configuration))
         api_response = api_instance.get_portfolio_stream_feed_authorize(api_version)
+
         return api_response
 
     def get_quantplay_product(self, exchange, product):
@@ -673,6 +665,7 @@ class Upstox(Broker):
             )
             Constants.logger.info("[UPDATE_RECEIVED] {}".format(order))
             self.order_updates.put(order)
+
         except Exception as e:
             traceback.print_exc()
             Constants.logger.error("[ORDER_UPDATE_PROCESSING_FAILED] {}".format(e))

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/xts.py

@@ -33,7 +33,7 @@ from quantplay.model.broker.generics import OrderType as NewOrderType
 from quantplay.model.broker.generics import ProductType as NewProductType
 
 # -# Suppress only the single warning from urllib3 needed.
-requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)  # type:ignore
+requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)  # type: ignore
 
 
 class XTS(Broker):
@@ -54,7 +54,7 @@ class XTS(Broker):
         load_instrument=True,
     ):
         super(XTS, self).__init__()
-        self.order_updates: Queue = order_updates  # type:ignore
+        self.order_updates: Queue | None = order_updates
         self.root_url = root_url
 
         try:
@@ -78,12 +78,10 @@ class XTS(Broker):
             codecs.decode(serialized_md_wrapper.encode(), "base64")
         )
 
-    def load_instrument(self, file_name=None):
+    def load_instrument(self, file_name: str | None = None) -> None:
         # TODO: Check for Futures
         try:
-            self.symbol_data = InstrumentData.get_instance().load_data(  # type:ignore
-                "xts_instruments"
-            )
+            self.symbol_data = InstrumentData.get_instance().load_data("xts_instruments")  # type: ignore
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
         except Exception:
             instruments = pd.read_csv(
@@ -522,7 +520,7 @@ class XTS(Broker):
 
         return exchange_code_map[exchange]
 
-    def get_ltp(self, exchange=None, tradingsymbol=None):
+    def get_ltp(self, exchange=None, tradingsymbol=None) -> float:
         exchange_code = self.get_exchange_code(exchange)
         exchange_token = self.symbol_data[f"{exchange}:{tradingsymbol}"]["exchange_token"]
 
@@ -745,7 +743,9 @@ class XTS(Broker):
 
             if new_ord["status"] == "TRIGGER PENDING" and new_ord["trigger_price"] == 0:
                 return
-            self.order_updates.put(new_ord)
+
+            if self.order_updates:
+                self.order_updates.put(new_ord)
 
         except Exception as e:
             print(e)

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/broker/zerodha.py

@@ -64,9 +64,9 @@ class Zerodha(Broker):
     def set_wrapper(self, serialized_wrapper):
         self.wrapper = pickle.loads(codecs.decode(serialized_wrapper.encode(), "base64"))
 
-    def initialize_symbol_data(self, save_as=None):
+    def initialize_symbol_data(self, save_as: str | None = None) -> None:
         try:
-            self.symbol_data = InstrumentData.get_instance().load_data(  # type:ignore
+            self.symbol_data = InstrumentData.get_instance().load_data(  # type: ignore
                 "zerodha_instruments"
             )
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")

quantplay-2.0.3/quantplay/exception/__init__.py

@@ -0,0 +1 @@
+from .exceptions import *  # noqa: F403

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/utils/constant.py

@@ -2,6 +2,7 @@ import logging
 import decimal
 from functools import wraps
 import time
+from typing import Any
 import numpy as np
 import json
 from datetime import datetime
@@ -14,13 +15,15 @@ formatter = logging.Formatter(
 
 class LoggerUtils:
     @staticmethod
-    def get_log_file_path(file_name):
+    def get_log_file_path(file_name: str) -> str:
         today_date = datetime.now()
 
         return "/tmp/" + file_name + "-" + today_date.strftime("%Y-%m-%d:01") + ".log"
 
     @staticmethod
-    def setup_logger(logger_name, log_file, level=logging.DEBUG):
+    def setup_logger(
+        logger_name: str, log_file: str, level=logging.DEBUG
+    ) -> logging.Logger:
         log_file = LoggerUtils.get_log_file_path(log_file)
         """Function setup as many loggers as you want"""
 
@@ -48,19 +51,16 @@ class Constants:
     tick_logger = LoggerUtils.setup_logger("tick_logger", "tick")
 
     @staticmethod
-    def myconverter(o):
+    def myconverter(o: Any):
         if isinstance(o, datetime):
             return o.__str__()
         if isinstance(o, decimal.Decimal):
-            # wanted a simple yield str(o) in the next line,
-            # but that would mean a yield on the line with super(...),
-            # which wouldn't work (see my comment below), so...
             return float(o)
         if isinstance(o, np.int64):  # type:ignore
             return int(o)
 
     @staticmethod
-    def round_to_tick(number):
+    def round_to_tick(number: int | float) -> float:
         return round(number * 20) / 20
 
 

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/utils/exchange.py

@@ -1,5 +1,4 @@
 class Market:
-
     TIMINGS = {
         # In (hour, minute) format
         "NSE": {

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/utils/pickle_utils.py

@@ -1,17 +1,18 @@
 import pickle
+from typing import Any
 from quantplay.utils.constant import timeit
 from threading import Lock
 
 
 class PickleUtils:
     @staticmethod
-    def save_data(data, file_name):
+    def save_data(data: Any, file_name: str):
         with open("/tmp/{}.pickle".format(file_name), "wb") as handle:
             pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL)
 
     @staticmethod
     @timeit(MetricName="PickleUtils:load_data")
-    def load_data(file_name):
+    def load_data(file_name: str):
         with open("/tmp/{}.pickle".format(file_name), "rb") as disk_data:
             unserialized_data = pickle.load(disk_data)
 
@@ -39,7 +40,7 @@ class InstrumentData:
         InstrumentData.__instance = self
 
     @timeit(MetricName="InstrumentData:load_data")
-    def load_data(self, file_name):
+    def load_data(self, file_name: str):
         if file_name in self.instrument_data:
             return self.instrument_data[file_name]
 

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay/utils/selenium_utils.py

@@ -18,7 +18,7 @@ class Selenium:
         wait_exponential_max=10000,
         stop_max_attempt_number=3,
     )
-    def get_browser(headless=True):
+    def get_browser(headless: bool = True):
         options = Options()
         if headless:
             options.add_argument("--headless")

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.0.2 → quantplay-2.0.3}/quantplay.egg-info/requires.txt

@@ -6,6 +6,7 @@ boto3
 numpy
 websocket-client
 smartapi-python
+logzero
 selenium
 requests
 pandas

{quantplay-2.0.2 → quantplay-2.0.3}/setup.py

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