quantplay 2.1.136__tar.gz → 2.1.138__tar.gz

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

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

{quantplay-2.1.136 → quantplay-2.1.138}/quantplay/broker/broker_factory.py

@@ -497,12 +497,13 @@ class BrokerFactory:
             )
             broker_data["user_id"] = broker_client.wrapper.userID
 
-            # Type C dealers must place orders as this sub-client. The login
+            # Type C dealers must place orders as this sub-client. Captured for
+            # every XTS type so reclassifying an account to C later works. The login
             # response is its only reliable source, so persist it for sessions
             # later restored from the stored wrapper (the dealer orderbook
             # fallback is empty every morning until the first order exists).
-            if broker_client.dealer_client_id:
-                broker_data["sub_client_id"] = broker_client.dealer_client_id
+            if broker_client.resolved_sub_client_id:
+                broker_data["sub_client_id"] = broker_client.resolved_sub_client_id
 
             broker_data["wrapper"] = codecs.encode(
                 pickle.dumps(broker_client.wrapper), "base64"

{quantplay-2.1.136 → quantplay-2.1.138}/quantplay/broker/generics/broker.py

@@ -910,6 +910,17 @@ class Broker(ABC):
         sleep_time: float = 10,
         max_modification_count: int = 10,
     ) -> None:
+        # TODO: think hard about how an exit that won't fill should end. Today:
+        # - skip_first_sleep is only cleared inside the branch it guards, so the
+        #   loop never sleeps and its re-prices run back to back.
+        # - Once the count exceeds max_modification_count it modifies to MARKET,
+        #   which brokers refuse from the API.
+        # - The "> 20" cancel only runs when max_modification_count is above 20.
+        #   Every caller passes 10 or less, so in practice the loop has no exit
+        #   if the order never completes.
+        # Widening the LIMIT buffer instead isn't a fix: exchange price bands
+        # reject prices too far from the LTP. In practice exits fill within the
+        # first few re-prices, so this is left as is for now.
         modification_count = {}
         skip_first_sleep = True
         while 1:

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

@@ -131,6 +131,17 @@ class Jainam(XTS):
 
         self.ORDER_POLLING_INTERVAL = 5
 
+    @property
+    def resolved_sub_client_id(self) -> str | None:
+        """The sub-client code discovered for this account, if any.
+
+        The login response carries `clientCodes` for every XTS type, but only
+        type C dealers resolve it into `dealer_client_id`. Exposing both means
+        generate_token can persist the code for A and B accounts too, so an
+        account later reclassified as type C already has what it needs.
+        """
+        return self.dealer_client_id or self._login_client_code
+
     @property
     def order_client_id(self) -> str:
         """Client ID for write operations.

{quantplay-2.1.136 → quantplay-2.1.138}/quantplay/broker/xts_utils_v2/ConnectV2.py

@@ -406,7 +406,7 @@ class XTSConnectV2(XTSCommon):
 
     def modify_order(
         self,
-        appOrderID: int,
+        appOrderID: int | str,
         modifiedProductType: XTSTypes.ProductType,
         modifiedOrderType: XTSTypes.OrderType,
         modifiedOrderQuantity: int,
@@ -420,7 +420,8 @@ class XTSConnectV2(XTSCommon):
         """The facility to modify your open orders by allowing you to change limit order to market or vice versa,
         change Price or Quantity of the limit open order, change disclosed quantity or stop-loss of any
         open stop loss order."""
-        appOrderID = int(appOrderID)
+        # order.modify rejects a numeric appOrderID ("must be a string")
+        appOrderID = str(appOrderID)
         params: dict[str, Any] = {
             "appOrderID": appOrderID,
             "modifiedProductType": modifiedProductType,

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

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

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

@@ -86,10 +86,11 @@ 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/test_sub_client_all_types.py
+tests/test_xts_v2_modify_order.py
 tests/wrapper/__init__.py
 tests/wrapper/aws/__init__.py
 tests/wrapper/aws/s3_test.py

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

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

{quantplay-2.1.136 → quantplay-2.1.138}/tests/test_jainam_xts.py

@@ -175,6 +175,7 @@ def test_generate_token_persists_sub_client_id_in_broker_data(
         wrapper=types.SimpleNamespace(userID=DEALER_ID),
         md_wrapper=types.SimpleNamespace(),
         dealer_client_id=SUB_CLIENT_ID,
+        resolved_sub_client_id=SUB_CLIENT_ID,
     )
     monkeypatch.setattr(broker_factory, "Jainam", lambda **kwargs: stub)
 
@@ -209,6 +210,7 @@ def test_generate_token_omits_sub_client_id_when_unresolved(
         wrapper=types.SimpleNamespace(userID=DEALER_ID),
         md_wrapper=types.SimpleNamespace(),
         dealer_client_id=None,
+        resolved_sub_client_id=None,
     )
     monkeypatch.setattr(broker_factory, "Jainam", lambda **kwargs: stub)
 

quantplay-2.1.138/tests/test_sub_client_all_types.py

@@ -0,0 +1,151 @@
+"""The sub-client code must be captured for every XTS type.
+
+Jainam resolves it into dealer_client_id only for type C dealers, but the
+login response carries clientCodes for A and B too. generate_token used to
+persist only dealer_client_id, so an account added as A or B had no
+sub_client_id stored - and reclassifying it to C later (which is exactly
+what a mis-answered "Account Type" leads to) left it unable to place an
+order until someone hand-wrote the field.
+"""
+
+import types
+from typing import Any
+
+import pytest
+
+from quantplay.broker import broker_factory, jainam_xts
+from quantplay.broker.jainam_xts import Jainam
+
+SUB = "JSR129"
+
+
+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 = "JSR129A77"
+
+    def session_login(self, root: str) -> dict[str, Any]:
+        return {
+            "type": "success",
+            "result": {
+                "token": "t",
+                "userID": "JSR129A77",
+                "isInvestorClient": False,
+                "clientCodes": [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",
+        load_instrument=False,
+        **kwargs,
+    )
+
+
+@pytest.mark.parametrize("xts_type", ["A", "B", "C"])
+def test_login_client_code_is_exposed_for_every_xts_type(
+    monkeypatch: Any, xts_type: str
+):
+    broker = login_jainam(monkeypatch, XTS_type=xts_type, is_dealer=True)
+
+    assert broker.resolved_sub_client_id == SUB
+
+
+def test_type_c_still_prefers_the_resolved_dealer_client(monkeypatch: Any):
+    broker = login_jainam(monkeypatch, XTS_type="C", is_dealer=True)
+
+    assert broker.dealer_client_id == SUB
+    assert broker.resolved_sub_client_id == SUB
+    assert broker.order_client_id == SUB
+
+
+def test_resolved_sub_client_is_none_when_login_gives_no_client_codes(
+    monkeypatch: Any,
+):
+    class NoCodes(FakeConnect):
+        def session_login(self, root: str) -> dict[str, Any]:
+            r = super().session_login(root)
+            r["result"].pop("clientCodes")
+            return r
+
+    monkeypatch.setattr(jainam_xts, "XTSConnectV2", NoCodes)
+    broker = Jainam(
+        api_key="k",
+        api_secret="s",
+        md_api_key="mk",
+        md_api_secret="ms",
+        XTS_type="A",
+        is_dealer=True,
+        load_instrument=False,
+    )
+
+    assert broker.resolved_sub_client_id is None
+
+
+@pytest.mark.parametrize("xts_type", ["A", "B", "C"])
+def test_generate_token_persists_the_sub_client_for_every_type(
+    monkeypatch: Any, xts_type: str
+):
+    stub = types.SimpleNamespace(
+        wrapper=types.SimpleNamespace(userID="JSR129A77"),
+        md_wrapper=types.SimpleNamespace(),
+        dealer_client_id=SUB if xts_type == "C" else None,
+        resolved_sub_client_id=SUB,
+    )
+    monkeypatch.setattr(broker_factory, "Jainam", lambda **kw: stub)
+
+    result = broker_factory.BrokerFactory().generate_token(
+        {
+            "username": "SUNILYADAV",
+            "nickname": "JSR129A77",
+            "broker": "Jainam",
+            "broker_data": {
+                "api_key": "k",
+                "api_secret": "s",
+                "md_api_key": "mk",
+                "md_api_secret": "ms",
+                "is_dealer": True,
+                "XTS_type": xts_type,
+            },
+        }
+    )
+
+    assert result["broker_data"]["sub_client_id"] == SUB
+
+
+def test_generate_token_omits_the_key_when_nothing_resolved(monkeypatch: Any):
+    stub = types.SimpleNamespace(
+        wrapper=types.SimpleNamespace(userID="X"),
+        md_wrapper=types.SimpleNamespace(),
+        dealer_client_id=None,
+        resolved_sub_client_id=None,
+    )
+    monkeypatch.setattr(broker_factory, "Jainam", lambda **kw: stub)
+
+    result = broker_factory.BrokerFactory().generate_token(
+        {
+            "username": "U",
+            "nickname": "N",
+            "broker": "Jainam",
+            "broker_data": {
+                "api_key": "k",
+                "api_secret": "s",
+                "md_api_key": "mk",
+                "md_api_secret": "ms",
+            },
+        }
+    )
+
+    assert "sub_client_id" not in result["broker_data"]

quantplay-2.1.138/tests/test_xts_v2_modify_order.py

@@ -0,0 +1,37 @@
+import json
+from unittest.mock import MagicMock
+
+from quantplay.broker.xts_utils_v2.ConnectV2 import XTSConnectV2
+
+APP_ORDER_ID = "18001263010000042909"
+
+
+def modify_body(app_order_id: int | str) -> dict:
+    connect = object.__new__(XTSConnectV2)
+    connect.isInvestorClient = False
+    connect._put = MagicMock(return_value={"type": "success"})
+
+    connect.modify_order(
+        appOrderID=app_order_id,
+        modifiedProductType="NRML",
+        modifiedOrderType="Limit",
+        modifiedOrderQuantity=90,
+        modifiedDisclosedQuantity=0,
+        modifiedLimitPrice=874.0,
+        modifiedStopPrice=0,
+        modifiedTimeInForce="DAY",
+        orderUniqueIdentifier="JSR129A43",
+        clientID="JSR129",
+    )
+
+    route, body = connect._put.call_args.args
+    assert route == "order.modify"
+    return json.loads(body)
+
+
+def test_modify_order_sends_app_order_id_as_string():
+    assert modify_body(APP_ORDER_ID)["appOrderID"] == APP_ORDER_ID
+
+
+def test_modify_order_stringifies_an_int_app_order_id():
+    assert modify_body(int(APP_ORDER_ID))["appOrderID"] == APP_ORDER_ID

quantplay-2.1.136/tests/test_instrument_freshness.py

@@ -1,347 +0,0 @@
-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)