quantplay 2.1.135__tar.gz → 2.1.136__tar.gz

{quantplay-2.1.135 → quantplay-2.1.136}/PKG-INFO

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

{quantplay-2.1.135 → quantplay-2.1.136}/quantplay/broker/kotak_utils/kotak_ws.py

@@ -10,6 +10,32 @@ from quantplay.broker.kotak_utils.kotak_ws_lib import HSIWebSocket
 
 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"
+
+# The order feed is served per data centre. Only "adc" used to be mapped, so
+# every other data centre silently fell back to the generic endpoint: the
+# socket connects, the CONNECTION frame is acknowledged, and then no order
+# event is ever delivered (the heartbeat is rejected too). Verified against a
+# live dataCenter="E41" account on 2026-09-01 - identical orders produced 0
+# events on the default URL and the full lifecycle on e41. Mapping matches
+# neo_api_client.NeoWebSocket.start_hsi_websocket.
+DATA_CENTER_ORDER_FEED_URLS = {
+    "adc": ORDER_FEED_URL_ADC,
+    "e21": ORDER_FEED_URL_E21,
+    "e22": ORDER_FEED_URL_E22,
+    "e41": ORDER_FEED_URL_E41,
+    "e43": ORDER_FEED_URL_E43,
+}
+
+
+def order_feed_url(data_center: str | None) -> str:
+    if not data_center:
+        return ORDER_FEED_URL
+
+    return DATA_CENTER_ORDER_FEED_URLS.get(data_center.lower(), ORDER_FEED_URL)
 
 
 class NeoWebSocket:
@@ -96,11 +122,7 @@ class NeoWebSocket:
             self.hsiWebsocket.send(json.dumps(payload))
 
     def start_hsi_websocket(self) -> None:
-        url = ORDER_FEED_URL
-
-        if self.data_center:
-            if self.data_center.lower() == "adc":
-                url = ORDER_FEED_URL_ADC
+        url = order_feed_url(self.data_center)
 
         self.hsiWebsocket = HSIWebSocket()
         self.hsiWebsocket.open_connection(

{quantplay-2.1.135 → quantplay-2.1.136}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.1.135 → quantplay-2.1.136}/quantplay.egg-info/SOURCES.txt

@@ -86,7 +86,9 @@ tests/__init__.py
 tests/conftest.py
 tests/test_deltax_positions.py
 tests/test_deltax_root_url.py
+tests/test_instrument_freshness.py
 tests/test_jainam_xts.py
+tests/test_kotak_order_feed_url.py
 tests/test_log_redaction.py
 tests/wrapper/__init__.py
 tests/wrapper/aws/__init__.py

{quantplay-2.1.135 → quantplay-2.1.136}/setup.py

@@ -21,7 +21,7 @@ requirements = [
 setup(
     name="quantplay",
     long_description=Path("README.md").read_text(),
-    version="2.1.135",
+    version="2.1.136",
     install_requires=requirements,
     tests_require=[],
     packages=find_packages(),

quantplay-2.1.136/tests/test_instrument_freshness.py

@@ -0,0 +1,347 @@
+import os
+import time
+import uuid
+from datetime import datetime, timedelta, timezone
+
+import pandas as pd
+import pytest
+
+import quantplay.utils.pickle_utils as pickle_utils_module
+from quantplay.broker.broker_factory import (
+    Broker as BrokerName,
+)
+from quantplay.broker.broker_factory import (
+    BrokerFactory,
+    broker_instruments_map,
+    instrument_cache,
+)
+from quantplay.broker.generics.broker import Broker
+from quantplay.broker.zerodha import Zerodha
+from quantplay.exception.exceptions import StaleDataFound
+from quantplay.utils.pickle_utils import InstrumentData, PickleUtils
+from quantplay.wrapper.aws import s3 as s3_module
+from quantplay.wrapper.aws.s3 import S3Utils
+
+
+def unique_name(prefix: str) -> str:
+    return f"{prefix}_{uuid.uuid4().hex[:10]}"
+
+
+class DummyBroker(Broker):
+    def get_exchange(self, exchange):
+        return exchange
+
+
+DummyBroker.__abstractmethods__ = frozenset()
+
+
+class FakeS3Client:
+    def __init__(self, response=None, error=None):
+        self.response = response
+        self.error = error
+
+    def head_object(self, Bucket, Key):
+        if self.error is not None:
+            raise self.error
+        return self.response
+
+
+@pytest.fixture
+def cleanup_paths():
+    paths = []
+    yield paths
+    for path in paths:
+        if os.path.exists(path):
+            os.remove(path)
+
+
+@pytest.fixture(autouse=True)
+def clear_instrument_cache():
+    instrument_cache.clear()
+    yield
+    instrument_cache.clear()
+
+
+def make_pickle(file_name: str, data: dict) -> str:
+    PickleUtils.save_data(data, file_name)
+    return f"/tmp/{file_name}.pickle"
+
+
+OLD_SYMBOL_DATA = {
+    "BFO:OLDSYMBOL": {
+        "broker_symbol": "OLDSYMBOL",
+        "tradingsymbol": "OLDSYMBOL",
+        "lot_size": 20,
+    }
+}
+
+NEW_SYMBOL_DATA = {
+    "BFO:SENSEX2671678400CE": {
+        "broker_symbol": "SENSEX2671678400CE",
+        "tradingsymbol": "SENSEX2671678400CE",
+        "lot_size": 20,
+    }
+}
+
+
+class TestS3LastModified:
+    def test_returns_datetime_on_success(self, monkeypatch):
+        expected = datetime(2026, 7, 16, 3, 16, tzinfo=timezone.utc)
+        monkeypatch.setattr(
+            s3_module.boto3,
+            "client",
+            lambda service: FakeS3Client(response={"LastModified": expected}),
+        )
+        assert S3Utils.last_modified("bucket", "key") == expected
+
+    def test_returns_none_on_failure(self, monkeypatch):
+        monkeypatch.setattr(
+            s3_module.boto3,
+            "client",
+            lambda service: FakeS3Client(error=Exception("404 Not Found")),
+        )
+        assert S3Utils.last_modified("bucket", "key") is None
+
+
+class TestPickleUtils:
+    def test_save_data_is_atomic_on_failure(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("atomic")
+        cleanup_paths.append(make_pickle(file_name, {"a": 1}))
+
+        def boom(*args, **kwargs):
+            raise RuntimeError("disk full")
+
+        monkeypatch.setattr(pickle_utils_module.pickle, "dump", boom)
+        with pytest.raises(Exception):
+            PickleUtils.save_data({"b": 2}, file_name)
+        monkeypatch.undo()
+
+        assert PickleUtils.load_data(file_name) == {"a": 1}
+
+    def test_instrument_data_reloads_when_pickle_changes(self, cleanup_paths):
+        file_name = unique_name("reload")
+        path = make_pickle(file_name, {"NSE:A": {"lot_size": 1}})
+        cleanup_paths.append(path)
+
+        instance = InstrumentData.get_instance()
+        assert instance.load_data(file_name) == {"NSE:A": {"lot_size": 1}}
+
+        make_pickle(file_name, {"NSE:B": {"lot_size": 2}})
+        new_time = time.time() + 10
+        os.utime(path, (new_time, new_time))
+
+        assert instance.load_data(file_name) == {"NSE:B": {"lot_size": 2}}
+
+    def test_instrument_data_serves_memory_copy_when_unchanged(self, cleanup_paths):
+        file_name = unique_name("cached")
+        path = make_pickle(file_name, {"NSE:A": {"lot_size": 1}})
+        cleanup_paths.append(path)
+
+        instance = InstrumentData.get_instance()
+        first = instance.load_data(file_name)
+        second = instance.load_data(file_name)
+        assert first is second
+
+
+class TestGetLotSize:
+    def test_missing_symbol_raises_stale_data_found(self):
+        broker = DummyBroker()
+        broker.symbol_data = {}
+
+        with pytest.raises(StaleDataFound) as exc_info:
+            broker.get_lot_size("BFO", "SENSEX2671678400CE")
+
+        assert "BFO:SENSEX2671678400CE" in str(exc_info.value)
+
+    def test_returns_lot_size_when_symbol_exists(self):
+        broker = DummyBroker()
+        broker.symbol_data = NEW_SYMBOL_DATA
+
+        assert broker.get_lot_size("BFO", "SENSEX2671678400CE") == 20
+
+
+class TestPickleFreshness:
+    def setup_method(self):
+        self.factory = BrokerFactory()
+
+    def test_missing_pickle_is_stale(self, monkeypatch):
+        monkeypatch.setattr(S3Utils, "last_modified", staticmethod(lambda b, k: None))
+        assert self.factory.is_instrument_pickle_fresh(unique_name("missing")) is False
+
+    def test_pickle_from_today_with_no_s3_csv_is_fresh(
+        self, monkeypatch, cleanup_paths
+    ):
+        file_name = unique_name("fresh")
+        cleanup_paths.append(make_pickle(file_name, OLD_SYMBOL_DATA))
+        monkeypatch.setattr(S3Utils, "last_modified", staticmethod(lambda b, k: None))
+
+        assert self.factory.is_instrument_pickle_fresh(file_name) is True
+
+    def test_pickle_from_yesterday_is_stale(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("stale_date")
+        path = make_pickle(file_name, OLD_SYMBOL_DATA)
+        cleanup_paths.append(path)
+        yesterday = time.time() - 86400
+        os.utime(path, (yesterday, yesterday))
+        monkeypatch.setattr(S3Utils, "last_modified", staticmethod(lambda b, k: None))
+
+        assert self.factory.is_instrument_pickle_fresh(file_name) is False
+
+    def test_pickle_older_than_s3_csv_is_stale(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("stale_s3")
+        cleanup_paths.append(make_pickle(file_name, OLD_SYMBOL_DATA))
+        s3_time = datetime.now(timezone.utc) + timedelta(hours=1)
+        monkeypatch.setattr(
+            S3Utils, "last_modified", staticmethod(lambda b, k: s3_time)
+        )
+
+        assert self.factory.is_instrument_pickle_fresh(file_name) is False
+
+    def test_pickle_newer_than_s3_csv_is_fresh(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("fresh_s3")
+        cleanup_paths.append(make_pickle(file_name, OLD_SYMBOL_DATA))
+        s3_time = datetime.now(timezone.utc) - timedelta(hours=2)
+        monkeypatch.setattr(
+            S3Utils, "last_modified", staticmethod(lambda b, k: s3_time)
+        )
+
+        assert self.factory.is_instrument_pickle_fresh(file_name) is True
+
+
+class TestSetBrokerInstruments:
+    def setup_method(self):
+        self.factory = BrokerFactory()
+
+    def _stale_pickle_setup(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("alicebluev2_test")
+        monkeypatch.setitem(
+            broker_instruments_map, BrokerName.ALICEBLUE_V2, file_name
+        )
+        path = make_pickle(file_name, OLD_SYMBOL_DATA)
+        cleanup_paths.append(path)
+        yesterday = time.time() - 86400
+        os.utime(path, (yesterday, yesterday))
+        monkeypatch.setattr(S3Utils, "last_modified", staticmethod(lambda b, k: None))
+        return file_name
+
+    def test_stale_pickle_triggers_refresh(self, monkeypatch, cleanup_paths):
+        file_name = self._stale_pickle_setup(monkeypatch, cleanup_paths)
+        broker = DummyBroker()
+        refresh_calls = []
+
+        def fake_refresh(name):
+            refresh_calls.append(name)
+            broker.symbol_data = NEW_SYMBOL_DATA
+            broker.initialize_broker_symbol_map()
+
+        monkeypatch.setattr(broker, "refresh_instruments", fake_refresh)
+
+        result = self.factory.set_broker_instruments(
+            broker_name=BrokerName.ALICEBLUE_V2, broker=broker
+        )
+
+        assert refresh_calls == [file_name]
+        assert "BFO:SENSEX2671678400CE" in result.symbol_data
+        assert (
+            instrument_cache.get(f"{BrokerName.ALICEBLUE_V2}_instruments")
+            == NEW_SYMBOL_DATA
+        )
+
+    def test_refresh_failure_serves_stale_pickle(self, monkeypatch, cleanup_paths):
+        self._stale_pickle_setup(monkeypatch, cleanup_paths)
+        broker = DummyBroker()
+
+        def fake_refresh(name):
+            raise Exception("s3 is down")
+
+        monkeypatch.setattr(broker, "refresh_instruments", fake_refresh)
+
+        result = self.factory.set_broker_instruments(
+            broker_name=BrokerName.ALICEBLUE_V2, broker=broker
+        )
+
+        assert "BFO:OLDSYMBOL" in result.symbol_data
+
+    def test_fresh_pickle_skips_refresh(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("alicebluev2_test")
+        monkeypatch.setitem(
+            broker_instruments_map, BrokerName.ALICEBLUE_V2, file_name
+        )
+        cleanup_paths.append(make_pickle(file_name, OLD_SYMBOL_DATA))
+        monkeypatch.setattr(S3Utils, "last_modified", staticmethod(lambda b, k: None))
+
+        broker = DummyBroker()
+
+        def fake_refresh(name):
+            raise AssertionError("refresh_instruments should not be called")
+
+        monkeypatch.setattr(broker, "refresh_instruments", fake_refresh)
+
+        result = self.factory.set_broker_instruments(
+            broker_name=BrokerName.ALICEBLUE_V2, broker=broker
+        )
+
+        assert "BFO:OLDSYMBOL" in result.symbol_data
+
+
+class TestRefreshInstruments:
+    def test_rebuilds_from_s3_and_updates_all_caches(self, monkeypatch, cleanup_paths):
+        file_name = unique_name("refresh_base")
+        cleanup_paths.append(f"/tmp/{file_name}.pickle")
+
+        local_csv = f"/tmp/quantplay-market-data/symbol_data/{file_name}.csv"
+        os.makedirs(os.path.dirname(local_csv), exist_ok=True)
+        with open(local_csv, "w") as f:
+            f.write("stale,csv\n")
+        cleanup_paths.append(local_csv)
+
+        df = pd.DataFrame(
+            [
+                {
+                    "exchange": "BFO",
+                    "broker_symbol": "SENSEX2671678400CE",
+                    "tradingsymbol": "SENSEX2671678400CE",
+                    "lot_size": 20,
+                }
+            ]
+        )
+
+        def fake_read_csv(bucket, key):
+            assert bucket == "quantplay-market-data"
+            assert key == f"symbol_data/{file_name}.csv"
+            return df
+
+        monkeypatch.setattr(S3Utils, "read_csv", staticmethod(fake_read_csv))
+
+        broker = DummyBroker()
+        broker.refresh_instruments(file_name)
+
+        assert "BFO:SENSEX2671678400CE" in broker.symbol_data
+        assert broker.symbol_data["BFO:SENSEX2671678400CE"]["lot_size"] == 20
+        assert not os.path.exists(local_csv)
+        assert "BFO:SENSEX2671678400CE" in PickleUtils.load_data(file_name)
+        assert (
+            InstrumentData.get_instance().load_data(file_name) == broker.symbol_data
+        )
+        assert broker.broker_symbol_map["SENSEX2671678400CE"] == "SENSEX2671678400CE"
+
+    def test_zerodha_rebuilds_from_live_instruments(self, cleanup_paths):
+        file_name = unique_name("zerodha_refresh")
+        cleanup_paths.append(f"/tmp/{file_name}.pickle")
+
+        class FakeWrapper:
+            def instruments(self):
+                return [
+                    {
+                        "exchange": "NFO",
+                        "tradingsymbol": "NIFTY26JUL25000CE",
+                        "lot_size": 75,
+                    }
+                ]
+
+        broker = object.__new__(Zerodha)
+        broker.wrapper = FakeWrapper()
+        broker.refresh_instruments(file_name)
+
+        assert broker.symbol_data["NFO:NIFTY26JUL25000CE"]["lot_size"] == 75
+        assert "NFO:NIFTY26JUL25000CE" in PickleUtils.load_data(file_name)

quantplay-2.1.136/tests/test_kotak_order_feed_url.py

@@ -0,0 +1,39 @@
+import pytest
+
+from quantplay.broker.kotak_utils.kotak_ws import (
+    ORDER_FEED_URL,
+    order_feed_url,
+)
+
+
+@pytest.mark.parametrize(
+    ("data_center", "expected"),
+    [
+        ("adc", "wss://cis.kotaksecurities.com/realtime"),
+        ("e21", "wss://e21.kotaksecurities.com/realtime"),
+        ("e22", "wss://e22.kotaksecurities.com/realtime"),
+        ("e41", "wss://e41.kotaksecurities.com/realtime"),
+        ("e43", "wss://e43.kotaksecurities.com/realtime"),
+    ],
+)
+def test_each_data_center_gets_its_own_endpoint(data_center: str, expected: str) -> None:
+    assert order_feed_url(data_center) == expected
+
+
+def test_data_center_is_case_insensitive() -> None:
+    # UserBrokerAccounts stores it upper-case ("E41"); Kotak's own client
+    # lower-cases before comparing.
+    assert order_feed_url("E41") == order_feed_url("e41")
+
+
+@pytest.mark.parametrize("data_center", [None, "", "zz"])
+def test_unknown_or_absent_data_center_falls_back(data_center: str | None) -> None:
+    assert order_feed_url(data_center) == ORDER_FEED_URL
+
+
+def test_non_adc_data_centers_are_not_the_default() -> None:
+    # The regression: e21/e22/e41/e43 silently resolved to ORDER_FEED_URL, so
+    # the socket connected to a data centre that holds no session for the
+    # account and delivered no order events.
+    for data_center in ("e21", "e22", "e41", "e43"):
+        assert order_feed_url(data_center) != ORDER_FEED_URL