tradingapi 0.3.12__tar.gz → 0.4.0__tar.gz

{tradingapi-0.3.12 → tradingapi-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.3.12
+Version: 0.4.0
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT
@@ -212,6 +212,16 @@ commissions:
 tz: "Asia/Kolkata"
 datapath: "/path/to/data"
 market_open_time: "09:15:00"
+market_close_time: "15:30:00" # Fallback when no schedule applies
+market_hours:
+  - effective_date: "2026-08-03"
+    exchanges:
+      NSE:
+        CASH: {open_time: "09:15:00", close_time: "15:35:00"}
+        FNO: {open_time: "09:15:00", close_time: "15:40:00"}
+      BSE:
+        CASH: {open_time: "09:15:00", close_time: "15:35:00"}
+        FNO: {open_time: "09:15:00", close_time: "15:40:00"}
 
 # FivePaisa Broker Configuration
 FIVEPAISA:
@@ -568,7 +578,7 @@ historical_data = broker.get_historical(
     date_end="2024-12-16",
     exchange="N",
     periodicity="1m",  # 1m, 5m, 1d, etc.
-    market_close_time="15:30:00"
+    # market_close_time="15:40:00"  # Optional per-call override
 )
 
 # Access data

{tradingapi-0.3.12 → tradingapi-0.4.0}/README.md

@@ -193,6 +193,16 @@ commissions:
 tz: "Asia/Kolkata"
 datapath: "/path/to/data"
 market_open_time: "09:15:00"
+market_close_time: "15:30:00" # Fallback when no schedule applies
+market_hours:
+  - effective_date: "2026-08-03"
+    exchanges:
+      NSE:
+        CASH: {open_time: "09:15:00", close_time: "15:35:00"}
+        FNO: {open_time: "09:15:00", close_time: "15:40:00"}
+      BSE:
+        CASH: {open_time: "09:15:00", close_time: "15:35:00"}
+        FNO: {open_time: "09:15:00", close_time: "15:40:00"}
 
 # FivePaisa Broker Configuration
 FIVEPAISA:
@@ -549,7 +559,7 @@ historical_data = broker.get_historical(
     date_end="2024-12-16",
     exchange="N",
     periodicity="1m",  # 1m, 5m, 1d, etc.
-    market_close_time="15:30:00"
+    # market_close_time="15:40:00"  # Optional per-call override
 )
 
 # Access data

{tradingapi-0.3.12 → tradingapi-0.4.0}/pyproject.toml

@@ -28,7 +28,7 @@ packages = ["tradingapi"]
 
 [project]
 name = "tradingapi"
-version = "0.3.12"
+version = "0.4.0"
 description = "Trade integration with brokers"
 readme = "README.md"
 license = "MIT"

{tradingapi-0.3.12 → tradingapi-0.4.0}/tests/test_calculate_delta_realtime_quotes.py

@@ -1,3 +1,4 @@
+import datetime as dt
 import math
 import sys
 from types import SimpleNamespace
@@ -12,11 +13,12 @@ from tradingapi import utils
 class CalculateDeltaRealtimeQuotesTest(unittest.TestCase):
     def test_calculate_delta_returns_nan_without_live_bid_ask(self):
         ticker = SimpleNamespace(bid=0.0, ask=0.0, prior_close=123.45)
+        expiry = (dt.date.today() + dt.timedelta(days=30)).strftime("%Y%m%d")
 
         with patch.object(utils, "get_price", return_value=ticker):
             delta = utils.calculate_delta(
                 brokers=[],
-                long_symbol="TCS_OPT_20260630_PUT_2160",
+                long_symbol=f"TCS_OPT_{expiry}_PUT_2160",
                 price_f=2325.1,
                 exchange="NFO",
                 mds="mds",

tradingapi-0.4.0/tests/test_market_hours_config.py

@@ -0,0 +1,140 @@
+import datetime as dt
+import sys
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, "/home/psharma/onedrive/code/tradingapi2")
+
+from tradingapi import config
+from tradingapi import market_hours
+from tradingapi import utils
+
+
+MARKET_CONFIG = {
+    "market_open_time": "09:15:00",
+    "market_close_time": "15:30:00",
+    "market_hours": [
+        {
+            "effective_date": "2026-08-03",
+            "exchanges": {
+                "NSE": {
+                    "CASH": {"open_time": "09:15:00", "close_time": "15:35:00"},
+                    "FNO": {"open_time": "09:15:00", "close_time": "15:40:00"},
+                },
+                "BSE": {
+                    "CASH": {"open_time": "09:15:00", "close_time": "15:35:00"},
+                    "FNO": {"open_time": "09:15:00", "close_time": "15:40:00"},
+                },
+            },
+        }
+    ],
+}
+
+
+class MarketHoursConfigTest(unittest.TestCase):
+    def setUp(self):
+        self.config = config.get_config()
+        self.config_patch = patch.object(self.config, "configs", MARKET_CONFIG)
+        self.config_patch.start()
+
+    def tearDown(self):
+        self.config_patch.stop()
+
+    def test_pre_effective_date_uses_legacy_fallback(self):
+        self.assertEqual(
+            config.get_market_close_time(
+                "NFO",
+                symbol="NIFTY_OPT_20260730_CALL_25000",
+                as_of="2026-07-30",
+            ),
+            "15:30:00",
+        )
+
+    def test_nse_cash_and_fno_are_resolved_separately(self):
+        self.assertEqual(
+            config.get_market_close_time("NSE", symbol="RELIANCE_STK___", as_of="2026-08-03"),
+            "15:35:00",
+        )
+        self.assertEqual(
+            config.get_market_close_time("NSE", symbol="NIFTY_FUT_20260827__", as_of="2026-08-03"),
+            "15:40:00",
+        )
+
+    def test_exchange_alias_infers_fno(self):
+        self.assertEqual(
+            config.get_market_close_time("BFO", as_of="2026-08-03"),
+            "15:40:00",
+        )
+        self.assertEqual(
+            config.get_market_close_time(
+                symbol="SENSEX_OPT_20260827_CALL_80000", as_of="2026-08-03"
+            ),
+            "15:40:00",
+        )
+
+    def test_session_bounds_uses_symbol_segment(self):
+        session_date = dt.date(2026, 8, 3)
+        cash = market_hours.session_bounds(session_date, exchange="NSE", symbol="NIFTY_IND___")
+        fno = market_hours.session_bounds(
+            session_date, exchange="NSE", symbol="NIFTY_OPT_20260827_CALL_25000"
+        )
+        self.assertEqual(cash[1].time(), dt.time(15, 35))
+        self.assertEqual(fno[1].time(), dt.time(15, 40))
+
+    def test_latest_close_covers_mixed_market_services(self):
+        self.assertEqual(
+            market_hours.latest_close_datetime(dt.date(2026, 8, 3)).time(),
+            dt.time(15, 40),
+        )
+
+    def test_latest_effective_schedule_wins(self):
+        updated = {
+            **MARKET_CONFIG,
+            "market_hours": MARKET_CONFIG["market_hours"]
+            + [
+                {
+                    "effective_date": "2027-01-01",
+                    "exchanges": {
+                        "NSE": {
+                            "FNO": {
+                                "open_time": "09:20:00",
+                                "close_time": "15:45:00",
+                            }
+                        }
+                    },
+                }
+            ],
+        }
+        with patch.object(self.config, "configs", updated):
+            self.assertEqual(
+                config.get_market_close_time("NFO", as_of="2027-01-02"),
+                "15:45:00",
+            )
+            self.assertEqual(
+                config.get_market_open_time("NFO", as_of="2027-01-02"),
+                "09:20:00",
+            )
+            self.assertFalse(
+                config.is_within_market_hours(
+                    dt.datetime(2027, 1, 2, 9, 17), exchange="NFO"
+                )
+            )
+            self.assertTrue(
+                config.is_within_market_hours(
+                    dt.datetime(2027, 1, 2, 9, 21), exchange="NFO"
+                )
+            )
+
+    def test_derivative_expiry_uses_schedule_for_expiry_date(self):
+        before = utils._derivative_expiry_datetime(
+            "20260730", "NIFTY_OPT_20260730_CALL_25000", "NFO"
+        )
+        after = utils._derivative_expiry_datetime(
+            "20260827", "NIFTY_OPT_20260827_CALL_25000", "NFO"
+        )
+        self.assertEqual(before.strftime("%H:%M:%S"), "15:30:00")
+        self.assertEqual(after.strftime("%H:%M:%S"), "15:40:00")
+
+
+if __name__ == "__main__":
+    unittest.main()

{tradingapi-0.3.12 → tradingapi-0.4.0}/tradingapi/attribution.py

@@ -25,6 +25,7 @@ import pandas as pd
 
 from . import trading_logger
 from .broker_base import BrokerBase
+from .config import get_market_close_time
 from .utils import (
     get_price_at_time,
     get_future_underlying_price,
@@ -54,6 +55,17 @@ _HISTORICAL_BROKER_REDIS_DB = 0
 _iv_cache: Dict[Tuple[str, str], float] = {}  # (symbol, time_key) -> iv
 
 
+def _market_close_datetime(date_str: str, symbol: str, exchange: str) -> dt.datetime:
+    close_time = get_market_close_time(
+        exchange=exchange, symbol=symbol, as_of=date_str
+    )
+    return dt.datetime.strptime(f"{date_str} {close_time}", "%Y%m%d %H:%M:%S")
+
+
+def _market_eod_datetime(date_str: str, symbol: str, exchange: str) -> dt.datetime:
+    return _market_close_datetime(date_str, symbol, exchange) - dt.timedelta(minutes=1)
+
+
 def _is_missing_number(value: Any) -> bool:
     return value is None or (isinstance(value, float) and value != value)
 
@@ -141,7 +153,7 @@ def get_historical_close_price(
             return None
 
     hist_broker = _get_historical_broker(broker)
-    eod_dt = dt.datetime.strptime(date_key + " 15:29:00", "%Y%m%d %H:%M:%S")
+    eod_dt = _market_eod_datetime(date_key, symbol, exchange)
     result = get_price_at_time(
         cast(BrokerBase, hist_broker), symbol, exchange, as_of=eod_dt, mds="mds", refresh_mapping=False
     )
@@ -321,7 +333,7 @@ def get_iv_for_symbol(
     try:
         if "_OPT_" in symbol:
             expiry_str = symbol.split("_")[2]
-            expiry_dt = dt.datetime.strptime(expiry_str + " 15:30:00", "%Y%m%d %H:%M:%S")
+            expiry_dt = _market_close_datetime(expiry_str, symbol, exchange)
             if time >= expiry_dt:
                 return 0.0
     except Exception:
@@ -813,8 +825,14 @@ def calculate_attribution_for_trade(
                 )
                 if len(prior_biz_date_str) == 10 and prior_biz_date_str[4] == "-":
                     prior_biz_date_str = prior_biz_date_str.replace("-", "")
-                entry_dt = dt.datetime.strptime(prior_biz_date_str + " 15:29:00", "%Y%m%d %H:%M:%S")
-            attribution_day_market_close = dt.datetime.strptime(attribution_date_str + " 15:30:00", "%Y%m%d %H:%M:%S")
+                entry_exchange = "BSE" if "SENSEX" in combo_symbol else "NSE"
+                entry_dt = _market_eod_datetime(
+                    prior_biz_date_str, combo_symbol, entry_exchange
+                )
+            attribution_exchange = "BSE" if "SENSEX" in combo_symbol else "NSE"
+            attribution_day_market_close = _market_close_datetime(
+                attribution_date_str, combo_symbol, attribution_exchange
+            )
             current_naive = get_naive_dt(current_time)
             current_dt = (
                 current_naive.to_pydatetime()
@@ -1204,7 +1222,7 @@ def mtm_entry_price(
 
         try:
             exchange = "BSE" if "SENSEX" in symbol else "NSE"
-            prior_eod_dt = dt.datetime.strptime(prior_date_str + " 15:29:00", "%Y%m%d %H:%M:%S")
+            prior_eod_dt = _market_eod_datetime(prior_date_str, symbol, exchange)
 
             if "?" in symbol:
                 legs = parse_combo_symbol(symbol)
@@ -1273,7 +1291,7 @@ def mtm_exit_price(
         except ValueError:
             mtm_date_obj = None
 
-    mtm_date_1530 = mtm_date_str + " 15:30:00"
+    mtm_close_dt = _market_close_datetime(mtm_date_str, symbol, exchange)
     today = dt.date.today()
 
     if broker is None:
@@ -1286,8 +1304,7 @@ def mtm_exit_price(
     else:
         try:
             exit_time_dt = parse_datetime(exit_time_str)
-            mtm_date_dt = parse_datetime(mtm_date_1530)
-            use_mtm_exit = exit_time_dt > mtm_date_dt
+            use_mtm_exit = exit_time_dt > mtm_close_dt
         except (ValueError, TypeError):
             use_mtm_exit = False
 
@@ -1318,7 +1335,7 @@ def mtm_exit_price(
     if use_mtm_exit:
         if mtm_date_obj and mtm_date_obj == today:
             current_time = dt.datetime.now().time()
-            market_close_time = dt.time(15, 30, 0)
+            market_close_time = mtm_close_dt.time()
             if current_time < market_close_time:
                 try:
                     price = _combo_or_single_price(None, last=True)
@@ -1330,7 +1347,7 @@ def mtm_exit_price(
                     )
 
             try:
-                mtm_eod_dt = dt.datetime.strptime(mtm_date_str + " 15:29:00", "%Y%m%d %H:%M:%S")
+                mtm_eod_dt = _market_eod_datetime(mtm_date_str, symbol, exchange)
                 mtm_price = _combo_or_single_price(mtm_eod_dt, last=False)
                 if mtm_price is not None:
                     return float(mtm_price)
@@ -1340,7 +1357,7 @@ def mtm_exit_price(
                 return entry_price
         else:
             try:
-                mtm_eod_dt = dt.datetime.strptime(mtm_date_str + " 15:29:00", "%Y%m%d %H:%M:%S")
+                mtm_eod_dt = _market_eod_datetime(mtm_date_str, symbol, exchange)
                 mtm_price = _combo_or_single_price(mtm_eod_dt, last=False)
                 if mtm_price is not None:
                     return float(mtm_price)

{tradingapi-0.3.12 → tradingapi-0.4.0}/tradingapi/broker_base.py

@@ -1024,7 +1024,7 @@ class BrokerBase(ABC):
         date_end: Union[str, dt.datetime, dt.date] = get_tradingapi_now().strftime("%Y-%m-%d"),
         exchange: str = "N",
         periodicity: str = "1m",
-        market_close_time: str = "15:30:00",
+        market_close_time: Optional[str] = None,
         refresh_mapping: bool = False,
     ) -> Dict[str, List[HistoricalData]]:
         """
@@ -1036,7 +1036,7 @@ class BrokerBase(ABC):
             date_end: End date for historical data (can be string, datetime, or date object)
             exchange: Exchange name
             periodicity: Data periodicity
-            market_close_time: Market close time
+            market_close_time: Optional override; configuration is used when omitted
             refresh_mapping: If True, load symbol mapping from date_end's symbols CSV instead of cached mapping.
 
         Returns:

{tradingapi-0.3.12 → tradingapi-0.4.0}/tradingapi/config/config_sample.yaml

@@ -1,6 +1,28 @@
 # bhavcopy path  - this is the path where symbol files from brokers are saved
 bhavcopy_folder : /home/psharma/onedrive/rfiles/data/bhavcopy
 
+tz: "Asia/Kolkata"
+datapath: "/path/to/data"
+market_open_time: "09:15:00"
+market_close_time: "15:30:00" # Backward-compatible fallback
+market_hours:
+  - effective_date: "2026-08-03"
+    exchanges:
+      NSE:
+        CASH:
+          open_time: "09:15:00"
+          close_time: "15:35:00"
+        FNO:
+          open_time: "09:15:00"
+          close_time: "15:40:00"
+      BSE:
+        CASH:
+          open_time: "09:15:00"
+          close_time: "15:35:00"
+        FNO:
+          open_time: "09:15:00"
+          close_time: "15:40:00"
+
 # Optional: proxy for broker HTTP requests (e.g. connect, save_symbol_data).
 # USE_PROXY: trading API calls. USE_PROXY_SYMBOL_DOWNLOAD: symbol master download only.
 proxy:

{tradingapi-0.3.12 → tradingapi-0.4.0}/tradingapi/config.py

@@ -541,6 +541,159 @@ def get_config() -> Config:
     return cast(Config, _config_instance)
 
 
+_EXCHANGE_ALIASES = {
+    "N": "NSE",
+    "NSE": "NSE",
+    "NFO": "NSE",
+    "B": "BSE",
+    "BSE": "BSE",
+    "BFO": "BSE",
+}
+_FNO_EXCHANGES = {"NFO", "BFO"}
+
+
+def _market_hours_date(value: Any) -> dt.date:
+    if value is None:
+        return dt.date.today()
+    if isinstance(value, dt.datetime):
+        return value.date()
+    if isinstance(value, dt.date):
+        return value
+    text = str(value).strip()[:10]
+    for fmt in ("%Y-%m-%d", "%Y%m%d"):
+        try:
+            return dt.datetime.strptime(text, fmt).date()
+        except ValueError:
+            continue
+    raise ValueError(f"Invalid market-hours date: {value}")
+
+
+def _market_time_or_default(value: Any, default: str) -> str:
+    candidate = str(value or default)
+    try:
+        dt.datetime.strptime(candidate, "%H:%M:%S")
+        return candidate
+    except ValueError:
+        return default
+
+
+def _get_market_session_time(
+    time_key: str,
+    fallback_key: str,
+    default: str,
+    exchange: Optional[str] = None,
+    market: Optional[str] = None,
+    symbol: Optional[str] = None,
+    as_of: Any = None,
+) -> str:
+    cfg = get_config()
+    fallback = _market_time_or_default(cfg.get(fallback_key, default), default)
+    symbol_key = str(symbol or "").upper()
+    exchange_key = str(exchange or "").strip().upper()
+    if not exchange_key:
+        exchange_key = "BSE" if "SENSEX" in symbol_key else "NSE"
+    normalized_exchange = _EXCHANGE_ALIASES.get(exchange_key, exchange_key)
+    if market is None:
+        normalized_market = (
+            "FNO"
+            if exchange_key in _FNO_EXCHANGES or "_FUT_" in symbol_key or "_OPT_" in symbol_key
+            else "CASH"
+        )
+    else:
+        market_key = str(market).strip().upper()
+        normalized_market = (
+            "FNO"
+            if market_key in {"FNO", "FO", "DERIVATIVES", "DERIVATIVE"}
+            else market_key
+        )
+
+    try:
+        target_date = _market_hours_date(as_of)
+    except ValueError:
+        return fallback
+
+    schedules = cfg.get("market_hours", []) or []
+    if isinstance(schedules, dict):
+        schedules = schedules.get("schedules", []) or []
+    applicable = []
+    for schedule in schedules if isinstance(schedules, list) else []:
+        if not isinstance(schedule, dict) or not schedule.get("effective_date"):
+            continue
+        try:
+            effective_date = _market_hours_date(schedule["effective_date"])
+        except ValueError:
+            continue
+        if effective_date <= target_date:
+            applicable.append((effective_date, schedule))
+
+    for _, schedule in sorted(applicable, key=lambda item: item[0], reverse=True):
+        exchanges = schedule.get("exchanges") or {}
+        exchange_hours = exchanges.get(normalized_exchange) or exchanges.get("DEFAULT") or {}
+        market_hours = exchange_hours.get(normalized_market) or exchange_hours.get("DEFAULT") or {}
+        session_time = market_hours.get(time_key) if isinstance(market_hours, dict) else None
+        if session_time:
+            return _market_time_or_default(session_time, fallback)
+    return fallback
+
+
+def get_market_open_time(
+    exchange: Optional[str] = None,
+    market: Optional[str] = None,
+    symbol: Optional[str] = None,
+    as_of: Any = None,
+    default: str = "09:15:00",
+) -> str:
+    """Return the effective open time for an exchange and market."""
+    return _get_market_session_time(
+        "open_time",
+        "market_open_time",
+        default,
+        exchange=exchange,
+        market=market,
+        symbol=symbol,
+        as_of=as_of,
+    )
+
+
+def get_market_close_time(
+    exchange: Optional[str] = None,
+    market: Optional[str] = None,
+    symbol: Optional[str] = None,
+    as_of: Any = None,
+    default: str = "15:30:00",
+) -> str:
+    """Return the effective close time for an exchange and market."""
+    return _get_market_session_time(
+        "close_time",
+        "market_close_time",
+        default,
+        exchange=exchange,
+        market=market,
+        symbol=symbol,
+        as_of=as_of,
+    )
+
+
+def is_within_market_hours(
+    timestamp: dt.datetime,
+    exchange: Optional[str] = None,
+    market: Optional[str] = None,
+    symbol: Optional[str] = None,
+    market_open_time: Optional[str] = None,
+    market_close_time: Optional[str] = None,
+) -> bool:
+    """Return whether a timestamp is inside its effective trading session."""
+    open_time = market_open_time or get_market_open_time(
+        exchange=exchange, market=market, symbol=symbol, as_of=timestamp
+    )
+    close_time = market_close_time or get_market_close_time(
+        exchange=exchange, market=market, symbol=symbol, as_of=timestamp
+    )
+    open_t = dt.datetime.strptime(open_time, "%H:%M:%S").time()
+    close_t = dt.datetime.strptime(close_time, "%H:%M:%S").time()
+    return open_t <= timestamp.time() < close_t
+
+
 def get_fno_freeze_limit(broker_name: str, underlying: str) -> Optional[int]:
     """Return max contracts per FNO order for (broker, underlying).
 

{tradingapi-0.3.12 → tradingapi-0.4.0}/tradingapi/dhan.py

@@ -34,7 +34,12 @@ from .broker_base import (
     Price,
     _normalize_as_of_date,
 )
-from .config import get_config
+from .config import (
+    get_config,
+    get_market_close_time,
+    get_market_open_time,
+    is_within_market_hours,
+)
 from chameli.dateutils import parse_datetime
 from .utils import (
     delete_broker_order_id,
@@ -1672,7 +1677,7 @@ class Dhan(BrokerBase):
         date_end=lambda x: _validate_datetime_input(x),
         exchange=lambda x: isinstance(x, str) and len(x.strip()) > 0,
         periodicity=lambda x: isinstance(x, str) and len(x.strip()) > 0,
-        market_close_time=lambda x: isinstance(x, str) and len(x.strip()) > 0,
+        market_close_time=lambda x: x is None or (isinstance(x, str) and len(x.strip()) > 0),
     )
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
     def get_historical(
@@ -1682,8 +1687,8 @@ class Dhan(BrokerBase):
         date_end: Union[str, dt.datetime, dt.date] = get_tradingapi_now().strftime("%Y-%m-%d"),
         exchange: str = "N",
         periodicity: str = "1m",
-        market_open_time: str = "09:15:00",
-        market_close_time: str = "15:30:00",
+        market_open_time: Optional[str] = None,
+        market_close_time: Optional[str] = None,
         refresh_mapping: bool = False,
     ) -> Dict[str, List[HistoricalData]]:
         """
@@ -1749,6 +1754,12 @@ class Dhan(BrokerBase):
                     out[long_symbol] = []
                     continue
                 security_id = int(security_id)
+                resolved_market_close_time = market_close_time or get_market_close_time(
+                    exchange=exchange, symbol=long_symbol, as_of=date_end
+                )
+                resolved_market_open_time = market_open_time or get_market_open_time(
+                    exchange=exchange, symbol=long_symbol, as_of=date_end
+                )
 
                 # Determine instrument_type from exchange_segment
                 _INDEX_UNDERLYINGS = ("NIFTY", "BANKNIFTY", "FINNIFTY", "MIDCPNIFTY", "SENSEX")
@@ -1800,9 +1811,6 @@ class Dhan(BrokerBase):
                     open_interest = raw.get("open_interest", [])
 
                     tz_ist = pytz.timezone("Asia/Kolkata")
-                    market_open = pd.to_datetime(market_open_time).time()
-                    market_close = pd.to_datetime(market_close_time).time()
-
                     for i in range(len(timestamps)):
                         try:
                             epoch = int(timestamps[i])
@@ -1811,7 +1819,13 @@ class Dhan(BrokerBase):
                             )
 
                             if use_intraday:
-                                if not (market_open <= ts.time() < market_close):
+                                if not is_within_market_hours(
+                                    ts,
+                                    exchange=exchange,
+                                    symbol=long_symbol,
+                                    market_open_time=market_open_time,
+                                    market_close_time=market_close_time,
+                                ):
                                     continue
                             else:
                                 ts = ts.floor("D")
@@ -1853,8 +1867,8 @@ class Dhan(BrokerBase):
                     # Always attempt when end date is today; replace any existing bar for that calendar day.
                     tz_ist = pytz.timezone("Asia/Kolkata")
                     target_d = date_end_dt.date()
-                    market_open_t = pd.to_datetime(market_open_time).time()
-                    market_close_t = pd.to_datetime(market_close_time).time()
+                    market_open_t = pd.to_datetime(resolved_market_open_time).time()
+                    market_close_t = pd.to_datetime(resolved_market_close_time).time()
 
                     intraday_response = self._fetch_dhan_historical(
                         security_id=security_id,