quantplay 2.1.45__tar.gz → 2.1.46__tar.gz

{quantplay-2.1.45 → quantplay-2.1.46}/PKG-INFO

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

{quantplay-2.1.45 → quantplay-2.1.46}/quantplay/broker/aliceblue.py

@@ -1,6 +1,9 @@
 import codecs
 import copy
+import json
 import pickle
+import threading
+import time
 import traceback
 from queue import Queue
 from typing import Any, Literal
@@ -10,7 +13,9 @@ from pya3 import Aliceblue as Alice
 from pya3 import OrderType as AliceOrderType
 from pya3 import ProductType as AliceProductType
 from pya3 import TransactionType as AliceTransactionType
+import requests
 from retrying import retry  # type: ignore
+import websocket  # type: ignore
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.exception.exceptions import (
@@ -40,6 +45,9 @@ logger = Constants.logger
 
 
 class Aliceblue(Broker):
+    websocket_url = "wss://ant.aliceblueonline.com/order-notify/websocket"
+    create_websocket_url = "https://ant.aliceblueonline.com/order-notify/ws/createWsToken"
+
     @retry(
         wait_exponential_multiplier=3000,
         wait_exponential_max=10000,
@@ -637,3 +645,140 @@ class Aliceblue(Broker):
         except Exception:
             traceback.print_exc()
             raise RetryableException("Failed to fetch data from Aliceblue")
+
+    def create_websocket_token(self):
+        user_token = self.alice.get_session_id()
+        session_ID = user_token["sessionID"]
+        headers = {
+            "Authorization": "Bearer Token" + " " + session_ID,
+            "Content-Type": "application/json",
+        }
+        response = requests.request("GET", self.create_websocket_url, headers=headers)
+        parse_data = response.json()
+        websocket_Token = parse_data["result"][0]["orderToken"]
+        return websocket_Token
+
+    def handle_order_update(self, order: dict[str, str]):
+        try:
+            out_order: OrderUpdateEvent = {
+                "placed_by": order["remarks"],
+                "tag": order["remarks"],
+                "order_id": order["norenordno"],
+                "exchange": order["exch"],
+                "tradingsymbol": order["tsym"],
+                "status": order["status"],
+                "order_type": order["prctyp"],
+                "price": float(order["prc"]),
+                "exchange_order_id": order["norenordno"],
+                "transaction_type": order["trantype"],
+                "product": order["pcode"],
+                "quantity": order["qty"],
+            }  # type: ignore
+
+            if out_order["exchange"] == "NSE":
+                out_order["tradingsymbol"] = out_order["tradingsymbol"].replace("-EQ", "")
+
+            elif out_order["exchange"] in ["NFO", "MCX"]:
+                out_order["tradingsymbol"] = self.broker_symbol_map[
+                    out_order["tradingsymbol"]
+                ]
+
+            if order["prctyp"] == "LMT":
+                out_order["order_type"] = "LIMIT"
+            elif order["prctyp"] == "MKT":
+                out_order["order_type"] = "MARKET"
+            elif order["prctyp"] == "SL-LMT":
+                out_order["order_type"] = "SL"
+
+            if order["pcode"] == "M":
+                out_order["product"] = "NRML"
+            elif order["pcode"] == "C":
+                out_order["product"] = "CNC"
+            elif order["pcode"] == "I":
+                out_order["product"] = "MIS"
+
+            if order["trantype"] == "S":
+                out_order["transaction_type"] = "SELL"
+            elif order["trantype"] == "B":
+                out_order["transaction_type"] = "BUY"
+            else:
+                logger.error(
+                    "[UNKNOW_VALUE] finvasia transaction type {} not supported".format(
+                        order["trantype"]
+                    )
+                )
+
+            if "trgprc" in order:
+                out_order["trigger_price"] = float(order["trgprc"])
+            else:
+                out_order["trigger_price"] = None
+
+            if order["status"] == "TRIGGER_PENDING":
+                out_order["status"] = "TRIGGER PENDING"
+            elif order["status"] == "CANCELED":
+                out_order["status"] = "CANCELLED"
+
+            logger.info(f"[ORDER_FEED] {order}")
+            if self.order_updates:
+                self.order_updates.put(out_order)
+
+        except Exception as e:
+            logger.error("[ORDER_UPDATE_PROCESSING_FAILED] {}".format(e))
+            traceback.print_exc()
+
+    def start_order_websocket(self):
+        ws_token = self.create_websocket_token()
+        print(f"{self.user_id}: WebSocket connection established.")
+        headers = {"Content-Type": "application/json"}
+        payload = {"orderToken": ws_token, "userId": self.user_id}
+        session_data = json.dumps(payload)
+
+        def on_message(ws: websocket.WebSocket, message: Any):
+            order = json.loads(message)
+
+            if order["t"] == "om":
+                self.handle_order_update(order)
+
+        def on_error(ws: websocket.WebSocket, error: Any):
+            if type(ws) is not websocket.WebSocketApp:  # type: ignore
+                error = ws
+
+            logger.error(f"{self.user_id}: WebSocket Closed. Reason: {error}")
+
+        def on_close(ws: websocket.WebSocket, close_status_code: int, close_msg: str):
+            logger.error(
+                f"{self.user_id}: WebSocket Closed. Status code: {close_status_code}, Reason: {close_msg}"
+            )
+
+        def on_open(ws: websocket.WebSocket):
+            print(f"{self.user_id}: WebSocket Connection Opened")
+            ws.send(session_data)
+            threading.Thread(
+                target=heart_beat_connection, args=(ws,), daemon=True
+            ).start()
+
+        def heart_beat_connection(ws: websocket.WebSocket):
+            while True:
+                try:
+                    payload = {"heartbeat": "h", "userId": self.user_id}
+                    hearbeat_data = json.dumps(payload)
+                    ws.send(hearbeat_data)
+                    time.sleep(55)
+
+                except websocket.WebSocketConnectionClosedException:
+                    break
+
+        # Create the WebSocket connection
+        ws = websocket.WebSocketApp(
+            self.websocket_url,
+            on_message=on_message,
+            on_error=on_error,
+            on_close=on_close,
+            on_open=on_open,
+            header=headers,  # Pass headers if required
+        )
+        ws.run_forever()  # type: ignore
+
+    def stream_order_data_ws(self):
+        thread = threading.Thread(target=self.start_order_websocket, daemon=True)
+        thread.start()

{quantplay-2.1.45 → quantplay-2.1.46}/quantplay/broker/angelone.py

@@ -1,6 +1,7 @@
 import binascii
 import copy
 import json
+import threading
 import traceback
 from queue import Queue
 from typing import Any
@@ -12,7 +13,9 @@ from requests.exceptions import ConnectionError, ConnectTimeout
 from retrying import retry  # type: ignore
 from SmartApi import SmartConnect  # type: ignore
 from SmartApi.smartExceptions import DataException  # type: ignore
+import websocket  # type: ignore
 
+from quantplay.broker.angelone_utils.angeloneWS import AngelOneOrderUpdateWS
 from quantplay.broker.generics.broker import Broker
 from quantplay.exception import RateLimitExceeded
 from quantplay.exception.exceptions import (
@@ -42,6 +45,7 @@ from quantplay.utils.pickle_utils import InstrumentData
 from quantplay.wrapper.aws.s3 import S3Utils
 
 logzero.logger.disabled = True
+logger = Constants.logger
 
 
 class AngelOne(Broker):
@@ -583,3 +587,75 @@ class AngelOne(Broker):
         except Exception as e:
             traceback.print_exc()
             raise RetryableException(str(e))
+
+    def handle_order_update(self, wsapp: websocket.WebSocket, message: str | bytes):
+        if not isinstance(message, str):
+            return
+
+        order: dict[str, str] | None = json.loads(message).get("orderData", None)
+
+        if order is None or order["orderid"] == "":
+            return
+
+        try:
+            out_order: OrderUpdateEvent = {
+                "placed_by": order["ordertag"],
+                "tag": order["ordertag"],
+                "order_id": order["orderid"],
+                "exchange_order_id": order["orderid"],
+                "exchange": order["exchange"],
+                "tradingsymbol": order["tradingsymbol"],
+                "status": order["status"],
+                "order_type": order["ordertype"],
+                "price": float(order["price"]),
+                "transaction_type": order["transactiontype"],
+                "product": order["producttype"],
+                "quantity": int(order["quantity"]),
+                "trigger_price": float(order["stoploss"]),
+            }  # type: ignore
+
+            out_order["tradingsymbol"] = self.broker_symbol_map[
+                out_order["tradingsymbol"]
+            ]
+
+            if order["status"] == "open":
+                out_order["status"] = "OPEN"
+            elif order["status"] == "cancelled":
+                out_order["status"] = "CANCELLED"
+            elif order["status"] == "trigger pending":
+                out_order["status"] = "TRIGGER PENDING"
+            elif order["status"] == "complete":
+                out_order["status"] = "COMPLETE"
+            elif order["status"] == "rejected":
+                out_order["status"] = "REJECTED"
+
+            if order["producttype"] == "DELIVERY":
+                out_order["product"] = "CNC"
+            elif order["producttype"] == "CARRYFORWARD":
+                out_order["product"] = "NRML"
+            elif order["producttype"] == "INTRADAY":
+                out_order["product"] = "MIS"
+
+            if order["ordertype"] == AngelOne.order_sl:
+                out_order["order_type"] = OrderType.sl
+
+            elif order["ordertype"] == AngelOne.order_slm:
+                out_order["order_type"] = OrderType.sl
+
+        except Exception as e:
+            logger.error(f"[ORDER_UPDATE_PROCESSING_FAILED] {e}")
+            traceback.print_exc()
+
+    def start_order_websocket(self) -> None:
+        ws_client = AngelOneOrderUpdateWS(
+            auth_token=self.wrapper.access_token,  # type: ignore
+            api_key=self.api_key,  # type: ignore
+            client_code=self.user_id,  # type: ignore
+            feed_token=self.wrapper.getfeedToken(),  # type: ignore
+        )
+        ws_client.on_message = self.handle_order_update
+        ws_client.connect()
+
+    def stream_order_data_ws(self):
+        thread = threading.Thread(target=self.start_order_websocket, daemon=True)
+        thread.start()

{quantplay-2.1.45 → quantplay-2.1.46}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.1.45 → quantplay-2.1.46}/setup.py

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