quantplay 2.0.181__tar.gz → 2.0.183__tar.gz

{quantplay-2.0.181 → quantplay-2.0.183}/PKG-INFO

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

{quantplay-2.0.181 → quantplay-2.0.183}/quantplay/broker/kotak.py

@@ -587,12 +587,12 @@ class Kotak(Broker):
         return order_type_map.get(order_type, order_type)  # type:ignore
 
     def get_quantplay_order_status(self, status: str) -> OrderStatusType:
-        if status in ["put order req received", "validation pending", "open pending"]:
+        if status in ["put order req received", "validation pending", "open pending", "modify pending", "modify validation pending"]:
             return "OPEN"
         if status == "cancel pending":
             return "CANCELLED"
         status = status.upper()
-        if status not in ["OPEN", "TRIGGER_PENDING", "CANCELLED", "REJECTED"]:
+        if status not in ["OPEN", "TRIGGER PENDING", "CANCELLED", "REJECTED", "COMPLETE"]:
             Constants.logger.error(f"{status} not supported for Kotak")
             return "INVALID STATUS"  # type:ignore
         return status  # type:ignore

quantplay-2.0.183/quantplay/broker/kotak_utils/kotak_ws.py

@@ -0,0 +1,93 @@
+from collections.abc import Callable
+import json
+import threading
+import time
+from typing import Any
+
+from quantplay.broker.kotak_utils.kotak_ws_lib import HSIWebSocket
+
+
+ORDER_FEED_URL = "wss://clhsi.kotaksecurities.com/realtime?sId={server_id}"
+
+
+class NeoWebSocket:
+    def __init__(self, sid: str | None, token: str | None, server_id: str | None):
+        self.hsiWebsocket = None
+        self.is_hsi_open = 0
+        self.sid = sid
+        self.access_token = token
+        self.server_id = server_id
+        self.on_message: Callable[[Any], None] | None = None
+        self.on_error: Callable[[Any], None] | None = None
+        self.on_close: Callable[[], None] | None = None
+        self.on_open: Callable[[], None] | None = None
+        self.hsi_thread = None
+
+    def on_hsi_open(self):
+        server = "WEB"
+        json_d = {
+            "type": "CONNECTION",
+            "Authorization": self.access_token,
+            "Sid": self.sid,
+            "source": server,
+        }
+        json_d = json.dumps(json_d)
+
+        if self.hsiWebsocket:
+            self.hsiWebsocket.send(json_d)
+
+        if self.on_open:
+            self.on_open()
+
+    def on_hsi_close(self):
+        if self.is_hsi_open == 1:
+            self.is_hsi_open = 0
+        if self.on_close:
+            self.on_close()
+
+    def on_hsi_error(self, error: Any):
+        if self.is_hsi_open == 1:
+            self.is_hsi_open = 0
+
+        if self.on_error:
+            self.on_error(error)
+        else:
+            print("Error Occurred in Websocket! Error Message ", error)
+
+    def on_hsi_message(self, message: Any):
+        if message:
+            if isinstance(message, str):
+                req = json.loads(message)
+                if req["type"] == "cn":
+                    self.is_hsi_open = 1
+                    threading.Thread(target=self.start_hsi_ping_thread).start()
+
+        if self.on_message:
+            self.on_message({"type": "order_feed", "data": message})
+
+    def start_hsi_ping_thread(self):
+        while self.hsiWebsocket and self.is_hsi_open:
+            time.sleep(30)
+            payload = {"type": "HB"}
+            self.hsiWebsocket.send(json.dumps(payload))
+
+    def start_hsi_websocket(self):
+        url = ORDER_FEED_URL.format(server_id=self.server_id)
+        self.hsiWebsocket = HSIWebSocket()
+        self.hsiWebsocket.open_connection(
+            url=url,
+            onopen=self.on_hsi_open,
+            onmessage=self.on_hsi_message,
+            onclose=self.on_hsi_close,
+            onerror=self.on_hsi_error,
+        )
+
+    def start_hsi_websocket_thread(self):
+        self.hsi_thread = threading.Thread(target=self.start_hsi_websocket)
+        self.hsi_thread.start()
+
+    def get_order_feed(self):
+        if self.hsiWebsocket is None or self.is_hsi_open == 0:
+            self.start_hsi_websocket_thread()
+        else:
+            print("you had already subscribed for order feed")

quantplay-2.0.183/quantplay/broker/kotak_utils/kotak_ws_lib.py

@@ -0,0 +1,142 @@
+from collections.abc import Callable
+import json
+import ssl
+from typing import Any
+
+import websocket
+
+
+class StartHSIServer:
+    def __init__(
+        self,
+        url: str,
+        onopen: Callable[[], None],
+        onmessage: Callable[[Any], None],
+        onerror: Callable[[Any], None],
+        onclose: Callable[[], None],
+    ):
+        self.openState = None
+        self.readyState = None
+        self.url = url
+        self.onopen = onopen
+        self.onmessage = onmessage
+        self.onerror = onerror
+        self.onclose = onclose
+        # self.token, self.sid = token, sid
+        global hsiWs
+        try:
+            # websocket.enableTrace(True)
+            hsiWs = websocket.WebSocketApp(
+                self.url,
+                on_open=self.on_open,
+                on_message=self.on_message,
+                on_error=self.on_error,
+                on_close=self.on_close,
+            )
+            hsiWs.run_forever(  # type: ignore
+                ping_interval=5, reconnect=5, sslopt={"cert_reqs": ssl.CERT_NONE}
+            )
+        except Exception:
+            print("WebSocket not supported!")
+
+    def on_message(self, ws: websocket.WebSocket, message: Any):
+        # print("Received message:", message)
+        self.onmessage(message)
+
+    def on_error(self, ws: websocket.WebSocket, error: Any):
+        print("Error:", error)
+        self.onerror(error)
+
+    def on_close(self, ws: websocket.WebSocket, close_status_code: Any, close_msg: Any):
+        # print("Connection closed")
+        self.openState = 0
+        self.readyState = 0
+        if hsiWs:
+            hsiWs.close()  # type: ignore
+        self.onclose()
+
+    def on_open(self, ws: websocket.WebSocket):
+        # print("Connection established HSWebSocket")
+        self.openState = 1
+        self.readyState = 1
+        self.onopen()
+
+
+class HSIWebSocket:
+    def __init__(self):
+        # self.hsiWs = None
+        self.hsiSocket = None
+        self.reqData = None
+        self.openState = 0
+        self.readyState = 0
+        self.url = None
+        self.onopen = None
+        self.onmessage = None
+        self.onclose = None
+        self.onerror = None
+        # self.token, self.sid = token, sid
+
+    def open_connection(
+        self,
+        url: str,
+        onopen: Callable[[], None],
+        onmessage: Callable[[Any], None],
+        onerror: Callable[[Any], None],
+        onclose: Callable[[], None],
+    ):
+        self.url = url
+        self.onopen = onopen
+        self.onmessage = onmessage
+        self.onclose = onclose
+        self.onerror = onerror
+        StartHSIServer(self.url, self.onopen, self.onmessage, self.onerror, self.onclose)
+
+    def send(self, d: Any):
+        reqJson = json.loads(d)
+        req = None
+        if reqJson["type"] == "CONNECTION":
+            if "Authorization" in reqJson and "Sid" in reqJson and "source" in reqJson:
+                req = {
+                    "type": "cn",
+                    "Authorization": reqJson["Authorization"],
+                    "Sid": reqJson["Sid"],
+                    "src": reqJson["source"],
+                }
+                self.reqData = req
+            else:
+                if "x-access-token" in reqJson and "src" in reqJson:
+                    req = {
+                        "type": "cn",
+                        "x-access-token": reqJson["x-access-token"],
+                        "source": reqJson["source"],
+                    }
+                    self.reqData = req
+                else:
+                    print("Invalid connection mode !")
+
+        elif reqJson["type"] == "HB":
+            # self.reqData=reqJson
+            req = {"type": "hb"}
+            self.reqData = req
+
+        else:
+            if reqJson["type"] == "FORCE_CONNECTION":
+                self.reqData = self.reqData["type"] = "fcn"  # type: ignore
+                req = self.reqData
+            else:
+                print("Invalid Request !")
+
+        if hsiWs and req:
+            js_obj = json.dumps(req)
+            hsiWs.send(js_obj)
+        else:
+            print(
+                "Unable to send request! Reason: Connection faulty or request not valid!"
+            )
+
+    def close(self):
+        self.openState = 0
+        self.readyState = 0
+
+        if hsiWs:
+            hsiWs.close()  # type: ignore

{quantplay-2.0.181 → quantplay-2.0.183}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.0.181 → quantplay-2.0.183}/quantplay.egg-info/SOURCES.txt

@@ -37,6 +37,9 @@ 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/kotak_utils/__init__.py
+quantplay/broker/kotak_utils/kotak_ws.py
+quantplay/broker/kotak_utils/kotak_ws_lib.py
 quantplay/broker/uplink/__init__.py
 quantplay/broker/uplink/uplink_utils.py
 quantplay/broker/xts_utils/Connect.py

{quantplay-2.0.181 → quantplay-2.0.183}/setup.py

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