quantplay 2.1.134__tar.gz → 2.1.136__tar.gz

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

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

{quantplay-2.1.134 → quantplay-2.1.136}/quantplay/broker/jainam_xts.py

@@ -1,5 +1,5 @@
 import traceback
-from typing import Literal
+from typing import Any, Literal
 
 import polars as pl
 
@@ -88,6 +88,15 @@ class Jainam(XTS):
         # on the dealer orderbook having orders.
         self._login_client_code: str | None = sub_client_id
 
+        # Classify the host we will actually connect to, so an explicitly
+        # supplied Jainam URL (or an empty string falling back to one) is not
+        # mistaken for a custom host. Computed here rather than from
+        # self.root_url later: set_wrapper overwrites root_url with the
+        # server-assigned connection string (".../9hostlookup"), which no
+        # longer matches XTS_ROOT_URL_MAP.
+        resolved_root_url = root_url or XTS_ROOT_URL_MAP[XTS_type]
+        self._custom_root_url = resolved_root_url not in XTS_ROOT_URL_MAP.values()
+
         # XTS type C dealers route through the broker's own infra; an
         # outbound proxy is unnecessary and just adds latency/failure modes.
         if XTS_type == "C":
@@ -97,7 +106,7 @@ class Jainam(XTS):
             # Other brokers (Delta X Broking) run the same XTS protocol on
             # their own server; they carry root_url in broker_data. Accounts
             # without one keep resolving through the Jainam host map.
-            root_url=root_url or XTS_ROOT_URL_MAP[XTS_type],
+            root_url=resolved_root_url,
             api_key=api_key,
             api_secret=api_secret,
             md_api_key=md_api_key,
@@ -252,6 +261,22 @@ class Jainam(XTS):
     def stream_order_updates(self) -> None:
         self.stream_order_updates_legacy()
 
+    def positions_api_response(self) -> dict[str, Any]:
+        """Delta X Broking's dealer-position endpoint is a no-op.
+
+        It answers "success" with an empty positionList for every clientID,
+        so a dealer on that host shows a permanently flat book. Its positions
+        come from the regular endpoint keyed by the dealer's client code.
+        Jainam's own hosts keep using the dealer endpoint.
+        """
+        if self._custom_root_url and self.is_dealer and self._login_client_code:
+            return self.invoke_xts_api(
+                self.wrapper.get_position_netwise,
+                clientID=self._login_client_code,
+            )
+
+        return super().positions_api_response()
+
     def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
         orders = super().orders(tag, add_ltp)
         orders = orders.with_columns(

{quantplay-2.1.134 → 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.134 → quantplay-2.1.136}/quantplay/broker/xts.py

@@ -423,8 +423,13 @@ class XTS(Broker):
     def holdings(self, add_ltp: bool = True) -> pl.DataFrame:
         return pl.DataFrame(schema=self.holidings_schema)
 
-    def positions(self, drop_cnc: bool = True, add_ltp: bool = True) -> pl.DataFrame:
-        api_response = self.invoke_xts_api(
+    def positions_api_response(self) -> dict[str, Any]:
+        """Fetch the raw position payload.
+
+        Split out so brokers whose XTS build routes positions differently
+        can override the call without duplicating the parsing below.
+        """
+        return self.invoke_xts_api(
             (
                 self.wrapper.get_dealerposition_netwise
                 if self.is_dealer
@@ -433,6 +438,9 @@ class XTS(Broker):
             clientID=None if self.is_dealer else self.ClientID,
         )
 
+    def positions(self, drop_cnc: bool = True, add_ltp: bool = True) -> pl.DataFrame:
+        api_response = self.positions_api_response()
+
         api_response = api_response["result"]["positionList"]
         positions_df = pl.DataFrame(api_response)
 

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

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

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

@@ -84,8 +84,11 @@ quantplay/wrapper/aws/__init__.py
 quantplay/wrapper/aws/s3.py
 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.134 → quantplay-2.1.136}/setup.py

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

quantplay-2.1.136/tests/test_deltax_positions.py

@@ -0,0 +1,178 @@
+"""Delta X Broking's dealer-position endpoint is a no-op.
+
+`get_dealerposition_netwise` answers `success` with an empty positionList
+for every clientID, so a Delta X dealer shows a permanently flat book.
+Positions only come back from the regular endpoint keyed by the dealer's
+client code (PRO17).
+
+Jainam dealers must keep using the dealer endpoint, so every behaviour
+here has a sibling asserting the no-root_url path is untouched.
+"""
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+from quantplay.broker import jainam_xts
+from quantplay.broker.jainam_xts import XTS_ROOT_URL_MAP, Jainam
+
+DELTAX_ROOT = "http://oms.deltaxbroking.com:3000"
+DELTAX_CLIENT = "PRO17"
+JAINAM_SUB = "JSR129"
+
+
+def build(
+    custom_root: bool,
+    is_dealer: bool = True,
+    sub_client_id: str | None = None,
+    XTS_type: str = "C",
+) -> tuple[Jainam, MagicMock]:
+    """A Jainam with login and instrument loading bypassed."""
+    broker = object.__new__(Jainam)
+    broker.XTS_type = XTS_type  # type: ignore[assignment]
+    broker.is_dealer = is_dealer
+    broker.ClientID = "*****" if (is_dealer and XTS_type != "C") else "BRS03"
+    broker._custom_root_url = custom_root  # pyright: ignore[reportPrivateUsage]
+    broker._login_client_code = sub_client_id  # pyright: ignore[reportPrivateUsage]
+    broker.dealer_client_id = None
+
+    wrapper = MagicMock()
+    wrapper.userID = "BRS03"
+    wrapper.get_dealerposition_netwise.return_value = {
+        "type": "success",
+        "result": {"positionList": []},
+    }
+    wrapper.get_position_netwise.return_value = {
+        "type": "success",
+        "result": {"positionList": [{"TradingSymbol": "X"}]},
+    }
+    broker.wrapper = wrapper
+
+    # invoke_xts_api wraps the call in retry/error handling; call straight through.
+    broker.invoke_xts_api = lambda fn, *a, **kw: fn(*a, **kw)  # type: ignore[method-assign]
+
+    return broker, wrapper
+
+
+# ---------------------------------------------------------------------------
+# Delta X: regular endpoint keyed by the dealer's client code
+# ---------------------------------------------------------------------------
+
+
+def test_custom_host_dealer_reads_positions_from_the_regular_endpoint():
+    broker, wrapper = build(custom_root=True, sub_client_id=DELTAX_CLIENT)
+
+    broker.positions_api_response()
+
+    wrapper.get_position_netwise.assert_called_once_with(clientID=DELTAX_CLIENT)
+    wrapper.get_dealerposition_netwise.assert_not_called()
+
+
+def test_custom_host_dealer_works_when_type_is_b():
+    """BRS03 runs as type B, so dealer_client_id is never resolved."""
+    broker, wrapper = build(
+        custom_root=True, sub_client_id=DELTAX_CLIENT, XTS_type="B"
+    )
+
+    broker.positions_api_response()
+
+    wrapper.get_position_netwise.assert_called_once_with(clientID=DELTAX_CLIENT)
+
+
+def test_custom_host_without_a_client_code_keeps_the_dealer_endpoint():
+    """No client code to key on — don't silently send None to the wrong API."""
+    broker, wrapper = build(custom_root=True, sub_client_id=None)
+
+    broker.positions_api_response()
+
+    wrapper.get_dealerposition_netwise.assert_called_once_with(clientID=None)
+    wrapper.get_position_netwise.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# Regression guards — JSR129A42 / JSR129A43 must not change
+# ---------------------------------------------------------------------------
+
+
+def test_jainam_dealer_still_uses_the_dealer_endpoint():
+    broker, wrapper = build(custom_root=False, sub_client_id=JAINAM_SUB)
+
+    broker.positions_api_response()
+
+    wrapper.get_dealerposition_netwise.assert_called_once_with(clientID=None)
+    wrapper.get_position_netwise.assert_not_called()
+
+
+def test_jainam_non_dealer_still_uses_its_own_client_id():
+    broker, wrapper = build(custom_root=False, is_dealer=False)
+
+    broker.positions_api_response()
+
+    wrapper.get_position_netwise.assert_called_once_with(clientID=broker.ClientID)
+    wrapper.get_dealerposition_netwise.assert_not_called()
+
+
+class FakeConnect:
+    """Stands in for XTSConnectV2 so __init__ runs the real login path."""
+
+    def __init__(self, apiKey: str, secretKey: str, root: str) -> None:
+        self.root = root
+        self.token = None
+        self.userID = "JSR129A42"
+
+    def session_login(self, root: str) -> dict[str, Any]:
+        return {
+            "type": "success",
+            "result": {
+                "token": "t",
+                "userID": "JSR129A42",
+                "isInvestorClient": False,
+                "clientCodes": [JAINAM_SUB],
+            },
+        }
+
+    def marketdata_login(self) -> dict[str, Any]:
+        return {"type": "success", "result": {"token": "m"}}
+
+
+def login_jainam(monkeypatch: Any, **kwargs: Any) -> Jainam:
+    monkeypatch.setattr(jainam_xts, "XTSConnectV2", FakeConnect)
+    return Jainam(
+        api_key="k",
+        api_secret="s",
+        md_api_key="mk",
+        md_api_secret="ms",
+        is_dealer=True,
+        load_instrument=False,
+        **kwargs,
+    )
+
+
+@pytest.mark.parametrize(
+    "root_url",
+    [
+        pytest.param(XTS_ROOT_URL_MAP["A"], id="explicit-jainam-a"),
+        pytest.param(XTS_ROOT_URL_MAP["C"], id="explicit-jainam-c"),
+        pytest.param("", id="empty-string-falls-back"),
+        pytest.param(None, id="omitted"),
+    ],
+)
+def test_hosts_resolving_to_jainam_are_never_custom(
+    monkeypatch: Any, root_url: str | None
+):
+    """Only a host outside XTS_ROOT_URL_MAP counts as custom.
+
+    An explicitly stored Jainam URL, and "" (falsy, so it falls back to the
+    map), both resolve to Jainam and must keep the dealer endpoint.
+    """
+    broker = login_jainam(monkeypatch, XTS_type="C", root_url=root_url)
+
+    assert broker._custom_root_url is False  # pyright: ignore[reportPrivateUsage]
+    assert broker.root_url in XTS_ROOT_URL_MAP.values()
+
+
+def test_a_non_jainam_host_is_custom(monkeypatch: Any):
+    broker = login_jainam(monkeypatch, XTS_type="C", root_url=DELTAX_ROOT)
+
+    assert broker._custom_root_url is True  # pyright: ignore[reportPrivateUsage]

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