programgarden 2.6.7__tar.gz → 2.7.1__tar.gz

{programgarden-2.6.7 → programgarden-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.6.7
+Version: 2.7.1
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -15,9 +15,9 @@ Requires-Dist: aiosqlite (>=0.20.0,<0.21.0)
 Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
-Requires-Dist: programgarden-community (>=2.3.1,<3.0.0)
-Requires-Dist: programgarden-core (>=2.6.3,<3.0.0)
-Requires-Dist: programgarden-finance (>=2.0.5,<3.0.0)
+Requires-Dist: programgarden-community (>=2.3.2,<3.0.0)
+Requires-Dist: programgarden-core (>=2.7.0,<3.0.0)
+Requires-Dist: programgarden-finance (>=2.0.6,<3.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
 Requires-Dist: pydantic (>=2.0.1,<3.0.0)

{programgarden-2.6.7 → programgarden-2.7.1}/programgarden/database/broker_snapshot.py

@@ -61,19 +61,22 @@ async def read_broker_snapshot(ls, *, execution_key, product, provider, trading_
         from programgarden_finance.ls.korea_stock.extension.valuation import collect_domestic_trading_positions
         from programgarden_finance.ls.korea_stock.extension.account_queries import collect_domestic_open_orders
 
+        # The collector returns t0424 rows (trade-basis balance, chegb=2), not
+        # CSPAQ12300 rows: the symbol is expcode and the held quantity janqty,
+        # the same fields the server startup gate reads.
         _, rows = await collect_domestic_trading_positions(ls.korea_stock().accno())
         for row in rows:
-            symbol = normalized_symbol(str(required(row, "IsuNo")), product)
+            symbol = normalized_symbol(str(required(row, "expcode")), product)
             if symbol in positions:
                 raise ReconciliationUnavailable("ambiguous_position_rows")
-            positions[symbol] = quantity(required(row, "BnsBaseBalQty"))
+            positions[symbol] = quantity(required(row, "janqty"))
         await asyncio.sleep(2)
         pending = await collect_domestic_open_orders(ls.korea_stock().accno())
         # t0425 is the documented current-day inquiry. Retain that observation
         # date for exact ledger matching; never widen it to yesterday's order.
         for row in pending:
             row["order_date"] = day
-        source = "CSPAQ12300+t0425"
+        source = "t0424+t0425"
     elif product == "overseas_stock":
         from programgarden_finance import COSOQ00201, COSAQ00102
 

{programgarden-2.6.7 → programgarden-2.7.1}/programgarden/database/workflow_position_tracker.py

@@ -2725,7 +2725,7 @@ class WorkflowPositionTracker:
         with sqlite3.connect(self.db_path) as conn:
             cursor = conn.cursor()
             cursor.execute("""
-                SELECT order_no, order_date, symbol, exchange, side, quantity
+                SELECT order_no, order_date, symbol, exchange, side, quantity, product
                 FROM workflow_orders
                 WHERE trading_mode = ? AND (price = 0 OR price IS NULL)
                 ORDER BY created_at DESC
@@ -2739,6 +2739,7 @@ class WorkflowPositionTracker:
                     "exchange": row[3],
                     "side": row[4],
                     "quantity": row[5],
+                    "product": row[6],
                 }
                 for row in cursor.fetchall()
             ]

{programgarden-2.6.7 → programgarden-2.7.1}/programgarden/deep_fixtures.py

@@ -79,7 +79,8 @@ def _config_symbols(config: Dict[str, Any]) -> Any:
 _FIXTURE_BARS = 64
 
 
-def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -> List[Dict[str, Any]]:
+def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0,
+                  minute_step: Optional[int] = None) -> List[Dict[str, Any]]:
     """Build a deterministic OHLCV series for one symbol (oldest bar first).
 
     The close path rises for the first ~⅔ of the window then declines into the
@@ -93,6 +94,9 @@ def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -
     price = base
     for i in range(n):
         day = _FIXTURE_ANCHOR + timedelta(days=i)
+        if minute_step:
+            # Minute bars carry YYYYMMDDHHMMSS stamps, like the live g3203/o3103 rows.
+            day = _FIXTURE_ANCHOR.replace(hour=9, minute=30) + timedelta(minutes=i * minute_step)
         # Rise toward the peak, then ease back down — a gentle mean-reverting arc.
         if i <= peak:
             price = base + i * 0.8
@@ -101,7 +105,7 @@ def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -
         price = max(price, base * 0.5)
         bars.append(
             {
-                "date": day.strftime("%Y%m%d"),
+                "date": day.strftime("%Y%m%d%H%M%S" if minute_step else "%Y%m%d"),
                 "open": round(price - 0.5, 2),
                 "high": round(price + 1.0, 2),
                 "low": round(price - 1.0, 2),
@@ -112,7 +116,8 @@ def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -
     return bars
 
 
-def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = None) -> List[Dict[str, Any]]:
+def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = None,
+                         minute_step: Optional[int] = None) -> List[Dict[str, Any]]:
     """Build the per-symbol ``{symbol, exchange, time_series:[bars]}`` list that
     HistoricalDataNode emits at runtime. Downstream ConditionNode auto-iterates
     this list, so each entry must carry the keys its ``items.extract`` reads
@@ -125,7 +130,7 @@ def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = None) -> Lis
             {
                 "symbol": entry["symbol"],
                 "exchange": entry["exchange"],
-                "time_series": _ohlcv_series(entry["symbol"], base=100.0 + idx * 10),
+                "time_series": _ohlcv_series(entry["symbol"], base=100.0 + idx * 10, minute_step=minute_step),
             }
         )
     return entries
@@ -179,7 +184,8 @@ def market_data_fixture(config: Dict[str, Any], symbols_raw: Any = None, *, prod
     return {"values": values}
 
 
-def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None, *,
+                            minute_step: Optional[int] = None) -> Dict[str, Any]:
     """HistoricalDataNode deep fixture.
 
     Real shape (executor.py ``HistoricalDataNodeExecutor.execute`` return):
@@ -195,7 +201,7 @@ def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) ->
     """
     if symbols_raw is None:
         symbols_raw = config.get("symbol") or _config_symbols(config)
-    entries = _time_series_entries(config, symbols_raw)
+    entries = _time_series_entries(config, symbols_raw, minute_step=minute_step)
     single = entries[0] if len(entries) == 1 else None
     return {
         "value": single,

{programgarden-2.6.7 → programgarden-2.7.1}/programgarden/executor.py

@@ -1012,6 +1012,12 @@ class LSClientManager:
             (ls_instance, success: bool, error_message: str | None)
         """
         from programgarden_finance import LS
+        from programgarden_finance.ls.replay_transport import active_transport, replay_client
+
+        # Offline replay (ls_tape) only: a client whose REST TRs are answered from
+        # the recording. No login, no token provider, never cached or reused.
+        if active_transport() is not None:
+            return replay_client(paper_trading), True, None
         
         # 이미 해당 product의 인스턴스가 있고 로그인된 경우
         if product in cls._instances:
@@ -1102,6 +1108,54 @@ def _resolve_broker_credentials(
     return appkey, appsecret, paper_trading
 
 
+FUTURES_FILL_PRICE_LOOKBACK_DAYS = 1  # today and the previous local day
+
+
+def _futures_fill_price_memo(context: Any) -> Dict[str, Any]:
+    """Per-run memory of the futures fill-price recovery (kept on the context)."""
+    memo = getattr(context, "_futures_fill_price_memo", None)
+    if not isinstance(memo, dict):
+        memo = {"attempted": set(), "failures": 0}
+        try:
+            setattr(context, "_futures_fill_price_memo", memo)
+        except Exception:
+            pass
+    return memo
+
+
+def _futures_fill_price_candidates(orders: Any, context: Any) -> Dict[str, Dict[str, Any]]:
+    """Unpriced futures orders worth one CIDBQ01800 read, by order date.
+
+    Keeps orders of a futures product (rows without a product are kept: the
+    caller already chose the product), dated today or yesterday, with a broker
+    order number, that this run has not looked up yet.
+    """
+    from datetime import date, timedelta
+    from programgarden_finance.ls.overseas_futureoption.extension.execution_history import (
+        normalize_broker_identity,
+    )
+
+    today = date.today()
+    window = {
+        (today - timedelta(days=days)).strftime("%Y%m%d")
+        for days in range(FUTURES_FILL_PRICE_LOOKBACK_DAYS + 1)
+    }
+    attempted = _futures_fill_price_memo(context)["attempted"]
+    wanted: Dict[str, Dict[str, Any]] = {}
+    for order in orders or []:
+        if not isinstance(order, Mapping):
+            continue
+        product = order.get("product")
+        if product is not None and product not in FUTURES_PRODUCTS:
+            continue
+        identity = normalize_broker_identity(order.get("order_no"))
+        order_date = str(order.get("order_date") or "")
+        if not identity or order_date not in window or (order_date, identity) in attempted:
+            continue
+        wanted.setdefault(order_date, {})[identity] = order
+    return wanted
+
+
 def ensure_ls_login(
     appkey: str,
     appsecret: str,
@@ -5582,7 +5636,20 @@ class BrokerNodeExecutor(NodeExecutorBase):
             orders_without_price = context.get_workflow_orders_without_fill_price()
             if not orders_without_price:
                 return
-            
+            if product == "overseas_futures":
+                # Bounded (2.7.0): only today's/yesterday's futures orders that
+                # this run has not read yet. The broker node re-runs every
+                # scheduled cycle, and unpriced rows stay in the ledger forever
+                # (an order cancelled before any fill keeps price 0), so without
+                # this every cycle would log in and read again.
+                orders_without_price = [
+                    order
+                    for by_identity in _futures_fill_price_candidates(orders_without_price, context).values()
+                    for order in by_identity.values()
+                ]
+                if not orders_without_price:
+                    return
+
             context.log("info", f"Found {len(orders_without_price)} orders without fill price - syncing from history", node_id)
             
             from programgarden_finance import LS
@@ -5717,37 +5784,82 @@ class BrokerNodeExecutor(NodeExecutorBase):
         context: ExecutionContext,
         node_id: str,
     ) -> None:
-        """해외선물 체결내역에서 가격 동기화"""
+        """Recover missing futures fill prices from CIDBQ01800 order rows.
+
+        Bounded, because the broker node re-runs every scheduled cycle and
+        starts this read again while unpriced rows stay in the ledger forever
+        (an order cancelled before any fill keeps price 0):
+
+        - only futures orders dated today or yesterday (local dates, the clock
+          the futures order path stamps the ledger with);
+        - each order is looked up at most once per run: one CIDBQ01800 read per
+          order date that has an unpriced order this run has not read yet, so
+          a new unpriced order on a date already read causes one more read;
+        - the first failed read of a run is a warning, later ones are debug.
+
+        A row supplies a price only for the same broker order — OvrsFutsOrdNo
+        compared as the integer identity, because CIDBQ01800 zero-pads it
+        ("0000000614") while the order TRs answer "614" — on the same symbol
+        when the ledger row has one, with an executed quantity and a positive
+        AbrdFutsExecPrc (LS paper 2026-10-15: ``ExecQty=1``,
+        ``AbrdFutsExecPrc="24114.00000000000"``). The stored order number and
+        date are written back unchanged.
+
+        Until 2.7.0 this called a method that does not exist, so every attempt
+        ended in a logged warning before any request and no price was ever
+        recovered.
+        """
         try:
-            from programgarden_finance import CIDBQ01800
-            
-            # 오늘 날짜 기준 체결내역 조회
-            today = datetime.now().strftime("%Y%m%d")
-            
-            response = ls.overseas_futureoption().accno().해외선물체결내역조회(
-                body=CIDBQ01800.CIDBQ01800InBlock(
-                    QryDt=today,
-                )
+            from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01800.blocks import (
+                CIDBQ01800InBlock1,
             )
-            result = await response.req_async()
-            
-            if not result or not hasattr(result, 'block1') or not result.block1:
+            from programgarden_finance.ls.overseas_futureoption.extension.execution_history import (
+                normalize_broker_identity,
+            )
+
+            wanted = _futures_fill_price_candidates(orders, context)
+            if not wanted:
                 return
-            
-            # 체결내역에서 주문번호별 가격 추출
+            memo = _futures_fill_price_memo(context)
+
+            accno = ls.overseas_futureoption().accno()
             fill_history = []
-            for item in result.block1:
-                fill_history.append({
-                    "order_no": str(getattr(item, 'OrdNo', '')),
-                    "order_date": today,
-                    "fill_price": float(getattr(item, 'ExecPrc', 0)),
-                })
-            
+            for order_date, by_identity in wanted.items():
+                # Mark before the read: a failed or empty answer is not retried
+                # by the next cycles of this run.
+                memo["attempted"].update((order_date, identity) for identity in by_identity)
+                result = await accno.CIDBQ01800(body=CIDBQ01800InBlock1(
+                    RecCnt=1, IsuCodeVal="", OrdDt=order_date, ThdayTpCode="",
+                    OrdStatCode="0", BnsTpCode="0", QryTpCode="1", OrdPtnCode="00",
+                    OvrsDrvtFnoTpCode="A",
+                )).req_async()
+                if getattr(result, "error_msg", None):
+                    level = "warning" if memo["failures"] == 0 else "debug"
+                    memo["failures"] += 1
+                    context.log(level, f"CIDBQ01800 fill price read failed ({order_date}): {result.error_msg}", node_id)
+                    continue
+                for row in getattr(result, "block2", None) or []:
+                    order = by_identity.get(normalize_broker_identity(getattr(row, "OvrsFutsOrdNo", None)))
+                    price = getattr(row, "AbrdFutsExecPrc", None)
+                    executed = getattr(row, "ExecQty", 0) or 0
+                    if (order is None or isinstance(price, bool) or not isinstance(price, (int, float))
+                            or not math.isfinite(price) or price <= 0 or executed <= 0):
+                        continue
+                    ledger_symbol = str(order.get("symbol") or "").strip().upper()
+                    row_symbol = str(getattr(row, "IsuCodeVal", "") or "").strip().upper()
+                    if ledger_symbol and row_symbol and ledger_symbol != row_symbol:
+                        continue
+                    fill_history.append({
+                        "order_no": order["order_no"],
+                        "order_date": order["order_date"],
+                        "fill_price": float(price),
+                    })
+
             if fill_history:
                 updated = context.sync_workflow_fill_prices_from_history(fill_history)
                 if updated > 0:
                     context.log("info", f"Synced {updated} order fill prices from futures history", node_id)
-                    
+
         except Exception as e:
             context.log("warning", f"Failed to sync futures fill prices: {e}", node_id)
     
@@ -12486,7 +12598,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
     HistoricalDataNode executor - 과거 OHLCV 데이터 조회
     
     LS Finance Chart API를 사용하여 과거 차트 데이터를 조회합니다.
-    - Overseas stock: g3204 (daily/weekly/monthly/yearly; no intraday)
+    - Overseas stock: g3204 (daily/weekly/monthly/yearly), g3203 (1/5/10/15/30/60-minute bars)
     - 해외선물: o3108 (일봉), o3103 (분봉)
     """
 
@@ -12512,10 +12624,12 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         # The broker-specific fetch repeats this guard for direct/legacy callers.
         connection = config.get("connection")
         product = connection.get("product") if isinstance(connection, dict) else None
+        stock_minute_step = None
         if node_type == "OverseasStockHistoricalDataNode" or (
             node_type == "HistoricalDataNode" and product in (None, "overseas_stock")
         ):
-            self._stock_history_gubun(config.get("interval", "1d"))
+            tr_code, selector = self._stock_history_request(config.get("interval", "1d"))
+            stock_minute_step = selector if tr_code == "g3203" else None
         if node_type == "OverseasFuturesHistoricalDataNode" or (
             node_type == "HistoricalDataNode" and product in FUTURES_PRODUCTS
         ):
@@ -12536,7 +12650,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
                 _seed = _cfg_sym or _in_sym
             except Exception:
                 _seed = None
-            fixture = _df.historical_data_fixture(config, _seed)
+            fixture = _df.historical_data_fixture(config, _seed, minute_step=stock_minute_step)
             override = context.get_deep_fixture(node_id, node_type)
             return _df.apply_override(fixture, override)
 
@@ -12765,17 +12879,38 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         # 파싱 실패 시 오늘 날짜 반환
         return datetime.now().strftime("%Y%m%d")
 
-    @staticmethod
-    def _stock_history_gubun(interval: str) -> str:
-        """Reject unsupported periods instead of relabeling daily bars."""
-        periods = {"1d": "2", "1w": "3", "1M": "4", "1Y": "5"}
-        if not isinstance(interval, str) or interval not in periods:
+    # LS g3204 period selectors (gubun) and g3203 bar sizes (ncnt, minutes).
+    # Every ncnt below answered rsp_cd 00000 with bars of exactly that step on a
+    # live platform call (2026-10-18, NVDA): 1, 5, 10, 15, 30 and 60.
+    STOCK_PERIOD_GUBUN = {"1d": "2", "1w": "3", "1M": "4", "1Y": "5"}
+    STOCK_MINUTE_NCNT = {"1m": 1, "5m": 5, "10m": 10, "15m": 15, "30m": 30, "60m": 60}
+
+    @classmethod
+    def _stock_history_request(cls, interval: str) -> tuple:
+        """``("g3204", gubun)`` for a period, ``("g3203", ncnt)`` for minute bars.
+
+        Unknown values are refused instead of relabeling daily bars.
+        """
+        if isinstance(interval, str) and interval in cls.STOCK_PERIOD_GUBUN:
+            return "g3204", cls.STOCK_PERIOD_GUBUN[interval]
+        if isinstance(interval, str) and interval in cls.STOCK_MINUTE_NCNT:
+            return "g3203", cls.STOCK_MINUTE_NCNT[interval]
+        raise ValueError(
+            "UNSUPPORTED_STOCK_HISTORY_INTERVAL: OverseasStockHistoricalDataNode "
+            "supports 1d, 1w, 1M and 1Y through LS g3204 and 1m, 5m, 10m, 15m, 30m "
+            "and 60m minute bars through LS g3203; select a supported interval explicitly."
+        )
+
+    @classmethod
+    def _stock_history_gubun(cls, interval: str) -> str:
+        """The g3204 period selector; minute intervals and unknown values are refused."""
+        tr_code, selector = cls._stock_history_request(interval)
+        if tr_code != "g3204":
             raise ValueError(
-                "UNSUPPORTED_STOCK_HISTORY_INTERVAL: OverseasStockHistoricalDataNode "
-                "supports 1d, 1w, 1M and 1Y through LS g3204. "
-                "Intraday g3203 is not supported; select a supported period explicitly."
+                "UNSUPPORTED_STOCK_HISTORY_INTERVAL: g3204 reads 1d, 1w, 1M and 1Y; "
+                f"{interval} is a g3203 minute interval."
             )
-        return periods[interval]
+        return selector
 
     async def _fetch_overseas_stock(
         self,
@@ -12789,7 +12924,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         symbol_exchange_map: Dict[str, str] = None,
         symbols_raw: List[Dict[str, Any]] = None,
     ) -> List[Dict[str, Any]]:
-        """해외주식 차트 데이터 조회 (g3204)
+        """해외주식 차트 데이터 조회 (g3204 기간봉 / g3203 분봉)
         
         g3204 API 사용 (sdate, edate, qrycnt 지원):
         - g3103: date 기준 최근 30개만 반환 (제한적)
@@ -12799,7 +12934,9 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         """
         
         # Validate before credential access or login, outside the soft-failure handler.
-        gubun = self._stock_history_gubun(interval)
+        tr_code, selector = self._stock_history_request(interval)
+        gubun = selector if tr_code == "g3204" else None
+        ncnt = selector if tr_code == "g3203" else None
 
         credential = context.get_credential()
         if not credential:
@@ -12808,6 +12945,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         
         try:
             from programgarden_finance.ls.overseas_stock.chart.g3204.blocks import G3204InBlock
+            from programgarden_finance.ls.overseas_stock.chart.g3203.blocks import G3203InBlock
             
             ls, success, error = ensure_ls_login(
                 credential.get("appkey"),
@@ -12861,6 +12999,25 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
                     exchange = symbol_to_exchange.get(symbol) or exchcd_to_exchange.get(exchcd, "NASDAQ")
                     
                     keysymbol = f"{exchcd}{symbol}"
+
+                    if ncnt is not None:
+                        bars = await self._fetch_overseas_stock_minutes(
+                            api, G3203InBlock(
+                                delaygb="R",
+                                comp_yn="N",
+                                keysymbol=keysymbol,
+                                exchcd=exchcd,
+                                symbol=symbol,
+                                ncnt=ncnt,
+                                qrycnt=500,  # LS cap for an uncompressed page
+                                sdate=start_date,
+                                edate=end_date,
+                                cts_date="",
+                                cts_time="",
+                            ), symbol, context, node_id,
+                        )
+                        result_list.append({"symbol": symbol, "exchange": exchange, "time_series": bars})
+                        continue
                     
                     # g3204 API 사용 (sdate, edate, qrycnt 지원)
                     body = G3204InBlock(
@@ -12925,6 +13082,41 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             context.log("error", f"Historical data fetch error: {e}", node_id)
             return self._empty_historical_result(symbols, f"i18n:errors.HISTORICAL_DATA_FETCH_ERROR|error={e}")
 
+    async def _fetch_overseas_stock_minutes(self, api, body, symbol: str, context, node_id: str) -> List[Dict[str, Any]]:
+        """Read one g3203 page of overseas-stock N-minute bars, oldest first.
+
+        LS answers the newest ``qrycnt`` bars at or before ``edate`` within
+        ``sdate..edate`` (observed 2026-10-18: ascending rows, ``tr_cont=Y`` when
+        older bars exist). This reads that first page only, like the futures
+        o3103 path: the requested range is not guaranteed to be complete.
+        ``date`` is ``YYYYMMDD`` + ``loctime`` (``YYYYMMDDHHMMSS``, the exchange
+        local time label exactly as LS returns it); ``volume`` is ``exevol``.
+        Bars outside the regular session are kept as LS returns them; no
+        completion or finality flag is added.
+        """
+        result = await api.chart().g3203(body=body).req_async()
+        if getattr(result, "error_msg", None):
+            context.log("warning", f"g3203 {symbol}: {result.error_msg}", node_id)
+            return []
+        bars = []
+        for item in result.block1 or []:
+            day = getattr(item, "date", "") or ""
+            clock = getattr(item, "loctime", "") or ""
+            bars.append({
+                "date": f"{day}{clock}" if day and clock else day,
+                "open": float(item.open) if item.open else 0,
+                "high": float(item.high) if item.high else 0,
+                "low": float(item.low) if item.low else 0,
+                "close": float(item.close) if item.close else 0,
+                "volume": int(item.exevol) if item.exevol else 0,
+            })
+        bars.sort(key=lambda x: x["date"])
+        if not bars:
+            context.log("warning", f"No minute data for {symbol}", node_id)
+        else:
+            context.log("debug", f"Fetched {len(bars)} g3203 bars for {symbol} (ncnt={body.ncnt})", node_id)
+        return bars
+
     async def _fetch_overseas_futures(
         self,
         symbols: List[str],

{programgarden-2.6.7 → programgarden-2.7.1}/programgarden/replay_external.py

@@ -176,10 +176,54 @@ def source_recording(node_type, config, source, contract, *, as_of, item=None):
     return result
 
 
+def per_item_key(node_type, item):
+    """The key of one per-item recording in ``record["items"]``.
+
+    A symbol item is keyed ``EXCHANGE:SYMBOL`` (a domestic node's item without
+    an exchange is ``KRX:SYMBOL``, as the domestic schemas accept ``{symbol}``).
+    Any other item (a position row without an exchange, a number, a text, a
+    nested object) is keyed by its ``content_hash``. Recording authors use this
+    function so the worker and the author compute the same key.
+    """
+    from programgarden.validation_replay import content_hash
+    if isinstance(item, dict) and isinstance(item.get("symbol"), str) and item["symbol"]:
+        exchange = item.get("exchange")
+        if not exchange and node_type.startswith("KoreaStock"):
+            exchange = "KRX"
+        if isinstance(exchange, str) and exchange:
+            return exchange + ":" + item["symbol"]
+    return content_hash(item)
+
+
+def branch_item(context, config):
+    """``(split_id, index, item)`` for a node running inside a SplitNode branch, else None.
+
+    The branch runner passes ``_branch_scope = "<split_id>#<index>"`` in the
+    node config and publishes the whole array once on the split's ``items``
+    port before the first item runs. The item is read from that array by index,
+    never from the split's ``item`` port or ``_split_context`` state: parallel
+    branches overwrite those single slots while another item is still running.
+    """
+    scope = config.get("_branch_scope") if isinstance(config, dict) else None
+    if not isinstance(scope, str) or "#" not in scope:
+        return None
+    split_id, _, raw_index = scope.rpartition("#")
+    try:
+        index = int(raw_index)
+    except ValueError:
+        return None
+    items = context.get_output(split_id, "items")
+    if not isinstance(items, list) or not 0 <= index < len(items):
+        raise ContractViolation(split_id, "The split item of this branch is not available",
+                                "REPLAY_FIXTURE_REQUIRED")
+    return split_id, index, items[index]
+
+
 def external_record(fixture, node_id, node_type, config, context):
     record = fixture.get("nodes", {}).get(node_id)
     if not isinstance(record, dict):
         raise ContractViolation(node_id, "An explicit external recording is required", "REPLAY_FIXTURE_REQUIRED")
+    expected_item = None
     if context._iteration_total:
         item = context._iteration_item
         if not isinstance(item, dict) or not isinstance(item.get("symbol"), str) or not item["symbol"]:
@@ -191,6 +235,21 @@ def external_record(fixture, node_id, node_type, config, context):
         if not isinstance(exchange, str) or not exchange:
             raise ContractViolation(node_id, "An overseas recording requires exchange identity", "REPLAY_FIXTURE_REQUIRED")
         record = record.get("items", {}).get(exchange + ":" + item["symbol"])
+        expected_item = item
+    elif isinstance(record.get("items"), dict):
+        # A per-item group inside a SplitNode branch (a basket): select this
+        # item's recording. A flat recording (no "items") keeps its meaning: one
+        # request identity for every item, with no item bound (item null).
+        branch = branch_item(context, config)
+        if branch is None:
+            raise ContractViolation(node_id, "A per-item recording runs only for an iterated or split item",
+                                    "REPLAY_FIXTURE_REQUIRED")
+        split_id, index, expected_item = branch
+        key = per_item_key(node_type, expected_item)
+        record = record["items"].get(key)
+        if not isinstance(record, dict):
+            raise ContractViolation(node_id, f"No recording for split item {key} ({split_id}#{index})",
+                                    "REPLAY_FIXTURE_REQUIRED", {"split": split_id, "index": index, "key": key})
     if not isinstance(record, dict):
         raise ContractViolation(node_id, "No matching per-item recording", "REPLAY_FIXTURE_REQUIRED")
     if "request" not in record or "as_of" not in record or "item" not in record:
@@ -211,7 +270,7 @@ def external_record(fixture, node_id, node_type, config, context):
         raise ContractViolation(node_id, _mismatch_message(
             "Recording does not match the shared replay clock", ["as_of"]),
             "REPLAY_FIXTURE_MISMATCH", detail)
-    item = context._iteration_item if context._iteration_total else None
+    item = expected_item
     if content_hash(record["item"]) != content_hash(item):
         detail = mismatch_detail(record["item"], item)
         raise ContractViolation(node_id, _mismatch_message(