quantplay 2.0.8__tar.gz → 2.0.10__tar.gz

{quantplay-2.0.8 → quantplay-2.0.10}/PKG-INFO

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

{quantplay-2.0.8 → quantplay-2.0.10}/quantplay/broker/noren.py

@@ -1,12 +1,14 @@
 import json
 from queue import Queue
 import traceback
-from typing import Dict
+from typing import Callable, Dict, Literal
 
 import polars as pl
 from retrying import retry
 from json.decoder import JSONDecodeError
 
+from quantplay.broker.finvasia_utils.fa_noren import FA_NorenApi
+from quantplay.broker.ft_utils.ft_noren import FT_NorenApi
 from quantplay.broker.generics.broker import Broker
 from quantplay.exception.exceptions import (
     InvalidArgumentException,
@@ -47,7 +49,9 @@ class Noren(Broker):
         self.order_type_sl = "SL-LMT"
         self.trigger_pending_status = "TRIGGER_PENDING"
 
-    def set_attributes(self, response):
+        self.api: FA_NorenApi | FT_NorenApi
+
+    def set_attributes(self, response: Dict[str, str | None]) -> None:
         self.email = response["email"]
         self.user_id = response["actid"]
         self.full_name = response["uname"]
@@ -72,9 +76,10 @@ class Noren(Broker):
     def get_symbol(self, symbol, exchange=None):
         if symbol not in self.quantplay_symbol_map:
             return symbol
+
         return self.quantplay_symbol_map[symbol]
 
-    def get_transaction_type(self, transaction_type):
+    def get_transaction_type(self, transaction_type: Literal["BUY", "SELL"]):
         if transaction_type == "BUY":
             return "B"
         elif transaction_type == "SELL":
@@ -87,16 +92,19 @@ class Noren(Broker):
     def get_order_type(self, order_type):
         if order_type == OrderType.market:
             return "MKT"
+
         elif order_type == OrderType.sl:
             return "SL-LMT"
+
         elif order_type == OrderType.slm:
             return "SL-MKT"
+
         elif order_type == OrderType.limit:
             return "LMT"
 
         return order_type
 
-    def get_product(self, product):
+    def get_product(self, product: str):
         if product == "NRML":
             return "M"
         elif product == "CNC":
@@ -106,9 +114,7 @@ class Noren(Broker):
         elif product in ["M", "C", "I"]:
             return product
 
-        raise InvalidArgumentException(
-            "Product {} not supported for trading".format(product)
-        )
+        raise InvalidArgumentException(f"Product {product} not supported for trading")
 
     def event_handler_order_update(self, order):
         try:
@@ -117,14 +123,11 @@ class Noren(Broker):
             order["order_id"] = order["norenordno"]
             order["exchange_order_id"] = order["exchordid"]
             order["exchange"] = order["exch"]
-
-            # TODO translate symbol
-            # -EQ should be removed
-            # F&O symbol translation
             order["tradingsymbol"] = order["tsym"]
 
             if order["exchange"] == "NSE":
                 order["tradingsymbol"] = order["tradingsymbol"].replace("-EQ", "")
+
             elif order["exchange"] in ["NFO", "MCX"]:
                 order["tradingsymbol"] = self.broker_symbol_map[order["tradingsymbol"]]
 
@@ -210,7 +213,7 @@ class Noren(Broker):
                 "remarks": tag,
             }
             Constants.logger.info("[PLACING_ORDER] {}".format(json.dumps(data)))
-            response = self.api.place_order(  # type:ignore
+            response = self.api.place_order(
                 buy_or_sell=noren_transaction_type,
                 product_type=noren_product,
                 exchange=exchange,
@@ -227,10 +230,12 @@ class Noren(Broker):
             Constants.logger.info(
                 "[PLACE_ORDER_RESPONSE] {} input {}".format(response, json.dumps(data))
             )
-            if "norenordno" in response:
+
+            if response is not None and "norenordno" in response:
                 return response["norenordno"]
             else:
                 raise Exception(response)
+
         except Exception as e:
             traceback.print_exc()
             exception_message = "Order placement failed with error [{}]".format(str(e))
@@ -248,12 +253,21 @@ class Noren(Broker):
         tradingsymbol = self.get_symbol(tradingsymbol)
 
         token = self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["token"]
-        return float(self.api.get_quotes(exchange, str(token))["lp"])  # type:ignore
+        quote = self.api.get_quotes(exchange, str(token))
+
+        if quote is None:
+            raise BrokerException("Response from Broker for LTP is Invalid")
+
+        return float(quote["lp"])
 
     def live_data(self, exchange, tradingsymbol):
         tradingsymbol = self.get_symbol(tradingsymbol)
         token = self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["token"]
-        data = self.api.get_quotes(exchange, str(token))  # type:ignore
+        data = self.api.get_quotes(exchange, str(token))
+
+        if data is None:
+            raise BrokerException("Response from Broker for Market Data is Invalid")
+
         return {
             "ltp": float(data["lp"]),
             "upper_circuit": float(data["uc"]),
@@ -261,15 +275,20 @@ class Noren(Broker):
         }
 
     def order_history(self, order_id):
-        order_history = self.api.single_order_history(order_id)  # type:ignore
+        order_history = self.api.single_order_history(order_id)
+
+        if order_history is None:
+            raise BrokerException("Response from Broker for Order History is Invalid")
+
         order_details = order_history[0]
 
-        data = {}
-        data["order_id"] = order_id
-        data["order_type"] = order_details["prctyp"]
-        data["exchange"] = order_details["exch"]
-        data["quantity"] = order_details["qty"]
-        data["tradingsymbol"] = order_details["tsym"]
+        data = {
+            "order_id": order_id,
+            "order_type": order_details["prctyp"],
+            "exchange": order_details["exch"],
+            "quantity": order_details["qty"],
+            "tradingsymbol": order_details["tsym"],
+        }
 
         return data
 
@@ -289,6 +308,7 @@ class Noren(Broker):
 
         if "order_type" not in order_to_modify:
             order_to_modify["order_type"] = existing_details["order_type"]
+
         if "quantity" not in order_to_modify:
             order_to_modify["quantity"] = existing_details["quantity"]
 
@@ -308,33 +328,39 @@ class Noren(Broker):
                     order_to_modify["order_id"], response
                 )
             )
+
+            if response is None:
+                raise Exception("Response is None")
+
             return response
+
         except Exception as e:
-            exception_message = (
-                "OrderModificationFailed for {} failed with exception {}".format(
-                    order_to_modify["order_id"], e
-                )
-            )
-            Constants.logger.error("{}".format(exception_message))
+            exception_message = f"OrderModificationFailed for {order_to_modify['order_id']} failed with exception {e}"
+            Constants.logger.error(f"{exception_message}")
             raise e
 
     @timeit(MetricName="Finvasia:cancel_order")
     def cancel_order(self, order_id, variety=None):
-        self.api.cancel_order(order_id)  # type:ignore
+        self.api.cancel_order(order_id)
 
     def stream_order_data(self):
-        self.api.start_websocket(  # type:ignore
-            order_update_callback=self.event_handler_order_update
-        )
+        self.api.start_websocket(order_update_callback=self.event_handler_order_update)
 
     @timeit(MetricName="Finvasia:profile")
     def profile(self) -> UserBrokerProfileResponse:
+        if self.user_id is None:
+            raise Exception("User ID is unknown")
+
         response: UserBrokerProfileResponse = {
-            "user_id": self.user_id,  # type:ignore
-            "full_name": self.full_name,
-            "email": self.email,
+            "user_id": self.user_id,
         }
 
+        if self.full_name is not None:
+            response["full_name"] = self.full_name
+
+        if self.email is not None:
+            response["email"] = self.email
+
         return response
 
     @timeit(MetricName="Noren:holdings")
@@ -344,7 +370,7 @@ class Noren(Broker):
         stop_max_attempt_number=3,
     )
     def holdings(self):
-        holdings = self.api.get_holdings()  # type:ignore
+        holdings = self.api.get_holdings()
         if holdings is None or len(holdings) == 0:
             return pl.DataFrame(schema=self.holidings_schema)
 
@@ -387,27 +413,13 @@ class Noren(Broker):
         return holdings_df[list(self.holidings_schema.keys())].cast(self.holidings_schema)
 
     @timeit(MetricName="Finvasia:positions")
-    @retry(
-        wait_exponential_multiplier=3000,
-        wait_exponential_max=10000,
-        stop_max_attempt_number=3,
-        retry_on_exception=retry_exception,
-    )
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
-        positions_df = pl.DataFrame()
-        try:
-            positions = self.api.get_positions()  # type:ignore
-            if positions is None or len(positions) == 0:
-                return pl.DataFrame(schema=self.positions_schema)
-        except BrokerException:
-            raise
-        except JSONDecodeError:
-            raise BrokerException("Broker failed to send positions")
-        except Exception:
-            raise
+        positions = self.invoke_noren_api(self.api.get_positions)
 
-        positions_df = pl.DataFrame(positions)
+        if positions is None or len(positions) == 0:
+            return pl.DataFrame(schema=self.positions_schema)
 
+        positions_df = pl.DataFrame(positions)
         positions_df = positions_df.rename(
             {
                 "tsym": "tradingsymbol",
@@ -488,16 +500,9 @@ class Noren(Broker):
 
     @timeit(MetricName="Finvasia:orders")
     def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
-        try:
-            orders = self.api.get_order_book()  # type:ignore
-            if orders is None or len(orders) == 0:
-                return pl.DataFrame(schema=self.orders_schema)
-        except BrokerException:
-            raise
-        except JSONDecodeError:
-            raise BrokerException("Broker failed to send orders")
-        except Exception:
-            raise
+        orders = self.invoke_noren_api(self.api.get_order_book)
+        if orders is None or len(orders) == 0:
+            return pl.DataFrame(schema=self.orders_schema)
 
         orders_df = pl.DataFrame(orders)
 
@@ -632,6 +637,27 @@ class Noren(Broker):
 
         return orders_df[list(self.orders_schema.keys())].cast(self.orders_schema)
 
+    @retry(
+        wait_exponential_multiplier=3000,
+        wait_exponential_max=10000,
+        stop_max_attempt_number=3,
+        retry_on_exception=retry_exception,
+    )
+    def invoke_noren_api(self, fn: Callable, *args, **kwargs) -> Dict:
+        try:
+            response = fn(*args, **kwargs)
+            if "stat" in response and "not_ok" == response["stat"].lower():
+                raise TokenException(response["emsg"])
+            return response
+
+        except JSONDecodeError:
+            raise BrokerException("Failed to data from broker")
+
+        except Exception:
+            traceback.print_exc()
+            # raise RetryableException("Failed to data from broker")
+            raise Exception("Failed to data from broker")
+
     @timeit(MetricName="Finvasia:positions")
     @retry(
         wait_exponential_multiplier=1000,
@@ -640,9 +666,7 @@ class Noren(Broker):
         retry_on_exception=retry_exception,
     )
     def margins(self) -> Dict:
-        api_margins = self.api.get_limits()  # type:ignore
-        if "stat" in api_margins and "not_ok" == api_margins["stat"].lower():
-            raise TokenException(api_margins["emsg"])
+        api_margins = self.invoke_noren_api(self.api.get_limits)
 
         try:
             collateral = 0
@@ -653,8 +677,10 @@ class Noren(Broker):
                 api_margins["margin_used"] = 0
             else:
                 api_margins["margin_used"] = api_margins["marginused"]
+
             if "payin" not in api_margins:
                 api_margins["payin"] = 0
+
             margin_available = (
                 float(api_margins["cash"])
                 + float(collateral)
@@ -665,23 +691,28 @@ class Noren(Broker):
             margins = {}
             margins["margin_used"] = api_margins["margin_used"]
             margins["margin_available"] = margin_available
+
             try:
                 margins["cash"] = float(api_margins["cash"])
             except Exception:
                 margins["cash"] = 0
+
             margins["total_balance"] = float(api_margins["cash"]) + float(collateral)
 
             return margins
+
         except Exception as e:
             logger.error(f"[NOREN_MARGIN_ERROR] {e}")
             RetryableException("[NOREN] Failed to fetch account margin")
+
         return {}
 
     @timeit(MetricName="Finvasia:account_summary")
     def account_summary(self):
-        margins: Dict = self.margins()
         pnl = 0
+        margins: Dict = self.margins()
         positions = self.positions()
+
         if len(positions) > 0:
             pnl = positions["pnl"].sum()
 

{quantplay-2.0.8 → quantplay-2.0.10}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.0.8 → quantplay-2.0.10}/setup.py

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