Warn instead of raise on `start_dt`-trimmed frames

Downgrade the `start_dt`-trimming check in `open_history_client()`
from a `RuntimeError` raise to a warning log, allowing the caller
to still receive a (shorter) frame of bars (though we may need to still
specially handle such cases in the backfiller's biz logic layer).

Deats,
- add `trimmed_bars.size` guard to skip check on empty results.
- change condition to `>=` and log a warning with the short-frame
  size instead of raising.
- comment-out `raise RuntimeError` and breakpoint for future
  removal once confident.
- add docstring-style comment on `start_dt=` kwarg noting that
  `Client.bars()` doesn't truly support it (uses duration-style
  queries internally).

(this commit msg was generated in some part by [`claude-code`][claude-code-gh])
[claude-code-gh]: https://github.com/anthropics/claude-code

piker/brokers/ib/api.py

@@ -768,26 +768,48 @@ class Client:
         expiry: str = '',
         front: bool = False,
 
-    ) -> Contract:
+    ) -> Contract|list[Contract]:
         '''
         Get an unqualifed contract for the current "continous"
         future.
 
+        When input params result in a so called "ambiguous contract"
+        situation, we return the list of all matches provided by,
+
+        `IB.qualifyContractsAsync(..., returnAll=True)`
+
         '''
         # it's the "front" contract returned here
         if front:
-            con = (await self.ib.qualifyContractsAsync(
+            cons = (
-                ContFuture(symbol, exchange=exchange)
+                await self.ib.qualifyContractsAsync(
-            ))[0]
+                    ContFuture(symbol, exchange=exchange),
-        else:
+                    returnAll=True,
-            cons = (await self.ib.qualifyContractsAsync(
-                Future(
-                    symbol,
-                    exchange=exchange,
-                    lastTradeDateOrContractMonth=expiry,
                 )
-            ))
+            )
-            con = cons[0]
+        else:
+            cons = (
+                await self.ib.qualifyContractsAsync(
+                    Future(
+                        symbol,
+                        exchange=exchange,
+                        lastTradeDateOrContractMonth=expiry,
+                    ),
+                    returnAll=True,
+                )
+            )
+
+        con = cons[0]
+        if isinstance(con, list):
+            log.warning(
+                f'{len(con)!r} futes cons matched for input params,\n'
+                f'symbol={symbol!r}\n'
+                f'exchange={exchange!r}\n'
+                f'expiry={expiry!r}\n'
+                f'\n'
+                f'cons:\n'
+                f'{con!r}\n'
+            )
 
         return con
 
@@ -912,11 +934,17 @@ class Client:
             )
             exch = 'SMART' if not exch else exch
 
-        contracts: list[Contract] = [con]
+        if isinstance(con, list):
+            contracts: list[Contract] = con
+        else:
+            contracts: list[Contract] = [con]
+
         if qualify:
             try:
                 contracts: list[Contract] = (
-                    await self.ib.qualifyContractsAsync(con)
+                    await self.ib.qualifyContractsAsync(
+                        *contracts
+                    )
                 )
             except RequestError as err:
                 msg = err.message

piker/brokers/ib/feed.py

@@ -201,6 +201,15 @@ async def open_history_client(
                 fqme,
                 timeframe,
                 end_dt=end_dt,
+
+                # XXX WARNING, we don't actually use this inside
+                # `Client.bars()` since it isn't really supported,
+                # the API instead supports a "duration" of time style
+                # from the `end_dt` (or at least that was the best
+                # way to get it working sanely)..
+                # 
+                # SO, with that in mind be aware that any downstream
+                # logic based on this may be mostly futile Xp
                 start_dt=start_dt,
             )
             latency = time.time() - query_start
@@ -278,19 +287,27 @@ async def open_history_client(
                 trimmed_bars = bars_array[
                     bars_array['time'] >= start_dt.timestamp()
                 ]
-                if (
+                # XXX, should NEVER get HERE!
-                    trimmed_first_dt := from_timestamp(trimmed_bars['time'][0])
+                if trimmed_bars.size:
-                    !=
+                    trimmed_first_dt: datetime = from_timestamp(trimmed_bars['time'][0])
-                    start_dt
+                    if (
-                ):
+                        trimmed_first_dt
-                    # TODO! rm this once we're more confident it never hits!
+                        >=
-                    # breakpoint()
+                        start_dt
-                    raise RuntimeError(
+                    ):
-                        f'OHLC-bars array start is gt `start_dt` limit !!\n'
+                        msg: str = (
-                        f'start_dt: {start_dt}\n'
+                            f'OHLC-bars array start is gt `start_dt` limit !!\n'
-                        f'first_dt: {first_dt}\n'
+                            f'start_dt: {start_dt}\n'
-                        f'trimmed_first_dt: {trimmed_first_dt}\n'
+                            f'first_dt: {first_dt}\n'
-                    )
+                            f'trimmed_first_dt: {trimmed_first_dt}\n'
+                            f'\n'
+                            f'Delivering shorted frame of {trimmed_bars.size!r}\n'
+                        )
+                        log.warning(msg)
+                        # TODO! rm this once we're more confident it
+                        # never breaks anything (in the caller)!
+                        # breakpoint()
+                        # raise RuntimeError(msg)
 
                 # XXX, overwrite with start_dt-limited frame
                 bars_array = trimmed_bars

piker/brokers/ib/venues.py

@@ -43,6 +43,7 @@ from pendulum import (
 if TYPE_CHECKING:
     from ib_async import (
         TradingSession,
+        Contract,
         ContractDetails,
     )
     from exchange_calendars.exchange_calendars import (
@@ -82,7 +83,12 @@ def has_holiday(
 
     '''
     tz: str = con_deats.timeZoneId
-    exch: str = con_deats.contract.primaryExchange
+    con: Contract = con_deats.contract
+    exch: str = (
+        con.primaryExchange
+        or
+        con.exchange
+    )
 
     # XXX, ad-hoc handle any IB exchange which are non-std
     # via lookup table..