quantplay 2.1.65__tar.gz → 2.1.67__tar.gz

{quantplay-2.1.65 → quantplay-2.1.67}/PKG-INFO

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

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/angelone_utils/angeloneWS.py

@@ -1,7 +1,8 @@
 import ssl
-import websocket
 import time
 
+import websocket
+
 from quantplay.utils.constant import Constants
 
 logger = Constants.logger

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/broker_factory.py

@@ -187,6 +187,8 @@ class BrokerFactory:
                 consumer_secret=broker_data["consumer_secret"],
                 mobilenumber=broker_data["mobilenumber"],
                 password=broker_data["password"],
+                totp=broker_data.get("totp"),
+                mpin=broker_data.get("mpin"),
                 otp=broker_data.get("otp"),
                 load_instrument=False,
             )

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/kotak.py

@@ -7,6 +7,7 @@ from urllib.parse import urlencode
 
 import jwt
 import polars as pl
+import pyotp
 import requests
 import shortuuid  # type:ignore
 
@@ -48,6 +49,8 @@ class Kotak(Broker):
         consumer_secret: str | None = None,
         mobilenumber: str | None = None,
         password: str | None = None,
+        totp: str | None = None,
+        mpin: str | None = None,
         otp: str | None = None,
         configuration: dict[str, str] | None = None,
         load_instrument: bool = True,
@@ -55,28 +58,39 @@ class Kotak(Broker):
     ) -> None:
         super().__init__()
 
-        self.configuration: dict[str, str | None] = {
-            "fin_key": "X6Nk8cQhUgGmJ2vBdWw4sfzrz4L5En",
-        }
+        self.configuration: dict[str, str | None] = {}
+        self.version: Literal["NEW", "OLD"]
 
         if configuration:
             self.configuration = {
-                "fin_key": "X6Nk8cQhUgGmJ2vBdWw4sfzrz4L5En",
-                "bearer_token": configuration.get("bearer_token"),
-                "view_token": configuration.get("view_token"),
-                "sid": configuration.get("sid"),
-                "kotakUserId": configuration.get("kotakUserId"),
-                "edit_token": configuration.get("edit_token"),
-                "edit_sid": configuration.get("edit_sid"),
-                "edit_rid": configuration.get("edit_rid"),
-                "serverId": configuration.get("serverId"),
+                "Authorization": self.configuration.get(
+                    "Authorization", f"Bearer {configuration.get('bearer_token')}"
+                ),
+                "Sid": self.configuration.get("Sid", configuration.get("edit_sid")),
+                "Auth": self.configuration.get("Auth", configuration.get("edit_token")),
+                "serverId": self.configuration.get("serverId"),
+                **configuration,
             }
 
             if verify_config:
                 self.margins()  # To Verify Configuration
 
         elif consumer_key and consumer_secret and mobilenumber and password:
-            self.login(consumer_key, consumer_secret, mobilenumber, password)
+            if totp and mpin:
+                self.login_v2(
+                    consumer_key,
+                    consumer_secret,
+                    mobilenumber,
+                    password,
+                    user_id,
+                    totp,
+                    mpin,
+                )
+                self.version = "NEW"
+
+            else:
+                self.login(consumer_key, consumer_secret, mobilenumber, password)
+                self.version = "OLD"
 
         if otp:
             self.verify_2fa(otp)
@@ -106,6 +120,99 @@ class Kotak(Broker):
 
         self.initialize_broker_symbol_map()
 
+    def login_v2(
+        self,
+        consumer_key: str,
+        consumer_secret: str,
+        mobilenumber: str,
+        password: str,
+        user_id: str,
+        totp: str,
+        mpin: str,
+    ) -> None:
+        # *** Generate Authorization Token via converting consumer_key and consumer_secret into base64 ***
+
+        base64_string = str(consumer_key) + ":" + str(consumer_secret)
+        base64_token = base64_string.encode("ascii")
+
+        base64_bytes = base64.b64encode(base64_token)
+        final_base64_token = base64_bytes.decode("ascii")
+
+        # *** Generate Access Token ***
+
+        session_init = requests.post(
+            url=f"{SESSION_PROD_BASE_URL}oauth2/token",
+            headers={
+                "Authorization": "Basic " + final_base64_token,
+                "Content-Type": "application/json",
+            },
+            data=json.dumps({"grant_type": "client_credentials"}),
+        )
+
+        if not session_init.ok:
+            raise InvalidArgumentException(json.loads(session_init.content))
+
+        json_resp = json.loads(session_init.text)
+        self.configuration["Authorization"] = f"Bearer {json_resp.get('access_token')}"
+
+        # *** Generate View Token ***
+
+        view_token_resp = requests.post(
+            url=f"{PROD_BASE_URL}login/1.0/login/v6/totp/login",
+            headers={
+                "Authorization": self.configuration["Authorization"],
+                "neo-fin-key": "neotradeapi",
+                "Content-Type": "application/json",
+            },
+            data=json.dumps(
+                {
+                    "mobileNumber": mobilenumber,
+                    "ucc": user_id,
+                    "totp": pyotp.TOTP(str(totp)).now(),
+                }
+            ),
+        )
+        view_token = json.loads(view_token_resp.text)
+
+        view_token_val = view_token.get("data").get("token")
+        sid = view_token.get("data").get("sid")
+
+        # *** Generate Final Login Token ***
+
+        generate_otp_resp = requests.post(
+            url=f"{PROD_BASE_URL}login/1.0/login/v6/totp/validate",
+            headers={
+                "accept": "application/json",
+                "sid": sid,
+                "Auth": view_token_val,
+                "neo-fin-key": "neotradeapi",
+                "Content-Type": "application/json",
+                "Authorization": self.configuration["Authorization"],
+            },
+            data=json.dumps(
+                {
+                    "mobileNumber": mobilenumber,
+                    "mpin": mpin,
+                }
+            ),
+        )
+
+        login_resp = json.loads(generate_otp_resp.text)["data"]
+
+        if login_resp["status"] != "success":
+            raise TokenException("Kotak Failed to Login")
+
+        self.configuration = {
+            "Authorization": self.configuration["Authorization"],
+            "Sid": login_resp["sid"],
+            "Auth": login_resp["token"],
+            "serverId": login_resp["hsServerId"],
+            "dataCenter": login_resp["dataCenter"],
+            # "ucc": login_resp["ucc"],
+            # "kId": login_resp["kId"],
+            # "kType": login_resp["kType"],
+        }
+
     def login(
         self,
         consumer_key: str,
@@ -188,7 +295,16 @@ class Kotak(Broker):
             self.configuration["edit_sid"] = edit_token_resp.get("data").get("sid")
             self.configuration["edit_rid"] = edit_token_resp.get("data").get("rid")
             self.configuration["serverId"] = edit_token_resp.get("data").get("hsServerId")
-            self.user_id = edit_token_resp.get("data").get("ucc")
+            # self.user_id = edit_token_resp.get("data").get("ucc")
+
+            self.configuration = {
+                "Authorization": self.configuration.get(
+                    "Authorization", f"Bearer {self.configuration['bearer_token']}"
+                ),
+                "Sid": self.configuration.get("Sid", self.configuration["edit_sid"]),
+                "Auth": self.configuration.get("Auth", self.configuration["edit_token"]),
+                "serverId": self.configuration["serverId"],
+            }
 
     def order_history(self, order_id: str) -> pl.DataFrame:
         body = {"nOrdNo": order_id}
@@ -770,10 +886,10 @@ class Kotak(Broker):
         url = f"{PROD_BASE_URL}{url}"
 
         request_headers = {
-            "Authorization": f"Bearer {self.configuration['bearer_token']}",
-            "Sid": self.configuration["edit_sid"],
-            "Auth": self.configuration["edit_token"],
-            "neo-fin-key": self.configuration["fin_key"],
+            "Authorization": self.configuration["Authorization"],
+            "Sid": self.configuration["Sid"],
+            "Auth": self.configuration["Auth"],
+            "neo-fin-key": "neotradeapi",
             "Content-Type": content_type,
             "accept": "application/json",
         }
@@ -882,11 +998,15 @@ class Kotak(Broker):
         if self.order_updates:
             self.order_updates.put(quantplay_order)
 
-    def stream_order_data(self):
+    def stream_order_data(self) -> None:
         ws = NeoWebSocket(
-            sid=self.configuration.get("sid", ""),
-            token=self.configuration.get("edit_token", ""),
+            sid=self.configuration.get("Sid", self.configuration.get("sid", "")),
+            token=self.configuration.get(
+                "Auth", self.configuration.get("edit_token", "")
+            ),
             server_id=self.configuration.get("serverId", ""),
+            data_center=self.configuration.get("dataCenter"),
+            version=self.version,
         )
         ws.on_message = self.event_handler_order_update
         ws.on_error = lambda x: print(f"[KOTAK_WS_ERROR]: {self.user_id} {x}")

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/kotak_utils/kotak_ws.py

@@ -2,29 +2,46 @@ import json
 import threading
 import time
 from collections.abc import Callable
-from typing import Any
+from typing import Any, Literal
 
 from retrying import retry  # type: ignore
 
 from quantplay.broker.kotak_utils.kotak_ws_lib import HSIWebSocket
 
-ORDER_FEED_URL = "wss://clhsi.kotaksecurities.com/realtime?sId={server_id}"
+OLD_ORDER_FEED_URL = "wss://clhsi.kotaksecurities.com/realtime?sId={server_id}"
+
+ORDER_FEED_URL = "wss://mis.kotaksecurities.com/realtime"
+ORDER_FEED_URL_ADC = "wss://cis.kotaksecurities.com/realtime"
+ORDER_FEED_URL_E21 = "wss://e21.kotaksecurities.com/realtime"
+ORDER_FEED_URL_E22 = "wss://e22.kotaksecurities.com/realtime"
+ORDER_FEED_URL_E41 = "wss://e41.kotaksecurities.com/realtime"
+ORDER_FEED_URL_E43 = "wss://e43.kotaksecurities.com/realtime"
 
 
 class NeoWebSocket:
-    def __init__(self, sid: str | None, token: str | None, server_id: str | None):
+    def __init__(
+        self,
+        sid: str | None,
+        token: str | None,
+        server_id: str | None,
+        data_center: str | None,
+        version: Literal["OLD", "NEW"],
+    ) -> None:
         self.hsiWebsocket = None
         self.is_hsi_open = 0
         self.sid = sid
         self.access_token = token
         self.server_id = server_id
+        self.version: Literal["OLD", "NEW"] = version
+        self.data_center = data_center
+
         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):
+    def on_hsi_open(self) -> None:
         server = "WEB"
         json_d = {
             "type": "CONNECTION",
@@ -34,7 +51,7 @@ class NeoWebSocket:
         }
         json_d = json.dumps(json_d)
 
-        print(f"[KOTAK_OPEN_SEND]: {json_d}")
+        # print(f"[KOTAK_OPEN_SEND]: {json_d}")
 
         if self.hsiWebsocket:
             self.hsiWebsocket.send(json_d)
@@ -42,7 +59,7 @@ class NeoWebSocket:
         if self.on_open:
             self.on_open()
 
-    def on_hsi_close(self):
+    def on_hsi_close(self) -> None:
         if self.is_hsi_open == 1:
             self.is_hsi_open = 0
             self.reconnect()
@@ -55,10 +72,10 @@ class NeoWebSocket:
         wait_exponential_max=20000,
         stop_max_attempt_number=5,
     )
-    def reconnect(self):
+    def reconnect(self) -> None:
         self.start_hsi_websocket()
 
-    def on_hsi_error(self, error: Any):
+    def on_hsi_error(self, error: Any) -> None:
         if self.is_hsi_open == 1:
             self.is_hsi_open = 0
 
@@ -67,7 +84,7 @@ class NeoWebSocket:
         else:
             print("Error Occurred in Websocket! Error Message ", error)
 
-    def on_hsi_message(self, message: Any):
+    def on_hsi_message(self, message: Any) -> None:
         if message:
             if isinstance(message, str):
                 req = json.loads(message)
@@ -78,15 +95,32 @@ class NeoWebSocket:
         if self.on_message:
             self.on_message({"type": "order_feed", "data": message})
 
-    def start_hsi_ping_thread(self):
+    def start_hsi_ping_thread(self) -> None:
         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()
+    def start_hsi_websocket(self) -> None:
+        if self.version == "NEW":
+            url = ORDER_FEED_URL
+
+            if self.data_center:
+                if self.data_center.lower() == "adc":
+                    url = ORDER_FEED_URL_ADC
+                # elif self.data_center.lower() == "e21":
+                #     url = ORDER_FEED_URL_E21
+                # elif self.data_center.lower() == "e22":
+                #     url = ORDER_FEED_URL_E22
+                # elif self.data_center.lower() == "e41":
+                #     url = ORDER_FEED_URL_E41
+                # elif self.data_center.lower() == "e43":
+                #     url = ORDER_FEED_URL_E43
+
+        else:
+            url = OLD_ORDER_FEED_URL.format(server_id=self.server_id)
+
+        self.hsiWebsocket = HSIWebSocket(self.version)
         self.hsiWebsocket.open_connection(
             url=url,
             onopen=self.on_hsi_open,
@@ -95,11 +129,11 @@ class NeoWebSocket:
             onerror=self.on_hsi_error,
         )
 
-    def start_hsi_websocket_thread(self):
+    def start_hsi_websocket_thread(self) -> None:
         self.hsi_thread = threading.Thread(target=self.start_hsi_websocket)
         self.hsi_thread.start()
 
-    def get_order_feed(self):
+    def get_order_feed(self) -> None:
         if self.hsiWebsocket is None or self.is_hsi_open == 0:
             self.start_hsi_websocket_thread()
         else:

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/kotak_utils/kotak_ws_lib.py

@@ -14,7 +14,7 @@ class StartHSIServer:
         onmessage: Callable[[Any], None],
         onerror: Callable[[Any], None],
         onclose: Callable[[], None],
-    ):
+    ) -> None:
         self.openState = None
         self.readyState = None
         self.url = url
@@ -39,15 +39,17 @@ class StartHSIServer:
         except Exception:
             print("WebSocket not supported!")
 
-    def on_message(self, ws: websocket.WebSocket, message: Any):
+    def on_message(self, ws: websocket.WebSocket, message: Any) -> None:
         # print("Received message:", message)
         self.onmessage(message)
 
-    def on_error(self, ws: websocket.WebSocket, error: Any):
+    def on_error(self, ws: websocket.WebSocket, error: Any) -> None:
         print("Error:", error)
         self.onerror(error)
 
-    def on_close(self, ws: websocket.WebSocket, close_status_code: Any, close_msg: Any):
+    def on_close(
+        self, ws: websocket.WebSocket, close_status_code: Any, close_msg: Any
+    ) -> None:
         # print("Connection closed")
         self.openState = 0
         self.readyState = 0
@@ -55,7 +57,7 @@ class StartHSIServer:
             hsiWs.close()  # type: ignore
         self.onclose()
 
-    def on_open(self, ws: websocket.WebSocket):
+    def on_open(self, ws: websocket.WebSocket) -> None:
         # print("Connection established HSWebSocket")
         self.openState = 1
         self.readyState = 1
@@ -63,7 +65,7 @@ class StartHSIServer:
 
 
 class HSIWebSocket:
-    def __init__(self) -> None:
+    def __init__(self, version: str) -> None:
         # self.hsiWs = None
         self.hsiSocket = None
         self.reqData = None
@@ -74,6 +76,7 @@ class HSIWebSocket:
         self.onmessage = None
         self.onclose = None
         self.onerror = None
+        self.version = version
         # self.token, self.sid = token, sid
 
     def open_connection(
@@ -91,7 +94,7 @@ class HSIWebSocket:
         self.onerror = onerror
         StartHSIServer(self.url, self.onopen, self.onmessage, self.onerror, self.onclose)
 
-    def send(self, d: Any) -> None:
+    def send(self, d: str) -> None:
         reqJson = json.loads(d)
         req = None
 
@@ -115,7 +118,7 @@ class HSIWebSocket:
                 else:
                     print("Invalid connection mode !")
 
-            print(f"[KOTAK_OPEN_SEND]: {self.reqData}")
+            # print(f"[KOTAK_OPEN_SEND]: {self.reqData}")
 
         elif reqJson["type"] == "HB":
             # self.reqData=reqJson
@@ -131,6 +134,10 @@ class HSIWebSocket:
 
         if hsiWs and req:
             js_obj = json.dumps(req)
+
+            if self.version == "NEW":
+                js_obj = str(js_obj).replace('"', "").replace(" ", "")
+
             hsiWs.send(js_obj)
         else:
             print(

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.1.65 → quantplay-2.1.67}/setup.py

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

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/aliceblue.py

@@ -9,13 +9,13 @@ from queue import Queue
 from typing import Any, Literal
 
 import polars as pl
+import requests
+import websocket  # type: ignore
 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 (

{quantplay-2.1.65 → quantplay-2.1.67}/quantplay/broker/angelone.py

@@ -9,11 +9,11 @@ from typing import Any
 import logzero  # type: ignore
 import polars as pl
 import pyotp
+import websocket  # type: ignore
 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