programgarden 1.22.4__tar.gz → 1.23.1__tar.gz

{programgarden-1.22.4 → programgarden-1.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.22.4
+Version: 1.23.1
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 Author: 프로그램동산
 Author-email: coding@programgarden.com
@@ -15,7 +15,7 @@ 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 (>=1.13.8,<2.0.0)
-Requires-Dist: programgarden-core (>=1.14.3,<2.0.0)
+Requires-Dist: programgarden-core (>=1.14.5,<2.0.0)
 Requires-Dist: programgarden-finance (>=1.6.10,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)

{programgarden-1.22.4 → programgarden-1.23.1}/programgarden/client.py

@@ -4,14 +4,38 @@ ProgramGarden - Main Client
 Provides user-friendly API
 """
 
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Awaitable, TypeVar
 import asyncio
+import concurrent.futures
 
 from programgarden.resolver import WorkflowResolver, ValidationResult
 from programgarden.executor import WorkflowExecutor
 from programgarden_core.bases.listener import ExecutionListener
 from programgarden_core.models.resource import ResourceLimits
 
+_T = TypeVar("_T")
+
+
+def _run_coro_sync(coro: Awaitable[_T]) -> _T:
+    """Run an awaitable to completion from synchronous code without disturbing
+    the caller thread's event-loop state.
+
+    ``asyncio.run()`` creates a fresh loop and, on exit, calls
+    ``asyncio.set_event_loop(None)`` — leaving the *main thread* with no current
+    loop. Any later ``asyncio.get_event_loop()`` in the same process then raises
+    "There is no current event loop", which leaks across test boundaries as a
+    spurious failure (global-state pollution).
+
+    Running the coroutine inside a dedicated worker thread keeps that loop
+    lifecycle entirely off the caller thread, so the caller's loop state is
+    untouched. It also makes the sync wrappers safe to call from within an
+    already-running loop (where a direct ``asyncio.run`` would raise). The
+    coroutine itself still enforces its own timeout, so this adds no unbounded
+    wait.
+    """
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(lambda: asyncio.run(coro)).result()
+
 
 class ProgramGarden:
     """
@@ -50,6 +74,44 @@ class ProgramGarden:
         """
         return self.resolver.validate(definition)
 
+    def validate_deep(
+        self,
+        definition: Dict[str, Any],
+        *,
+        fixtures: Optional[Dict[str, Any]] = None,
+        timeout: float = 15.0,
+    ) -> ValidationResult:
+        """Deep-validate a workflow via virtual full-execution (never raises).
+
+        Runs the workflow once, end-to-end, in ``deep_validate`` mode (a strict
+        superset of ``dry_run``): no real order is ever placed, no notification is
+        dispatched, realtime/data nodes return schema-shaped fixtures so the flow
+        completes without waiting for live events or hitting the broker network,
+        and node failures are accumulated rather than aborting on the first one.
+        The result blocks (``is_valid=False``) if any node errors or the flow
+        does not run to completion.
+
+        Args:
+            definition: Workflow definition (JSON dict).
+            fixtures: Optional per-node fixture overrides, keyed by node id or
+                node type (merged shallowly on top of the default fixture).
+            timeout: Hard timeout (seconds) for the single validation pass.
+
+        Returns:
+            ValidationResult — ``errors`` carry structured per-node ErrorInfo;
+            ``is_valid`` is True only when nothing failed and the flow completed.
+
+        Example:
+            >>> pg = ProgramGarden()
+            >>> result = pg.validate_deep(workflow)
+            >>> if not result.is_valid:
+            ...     for err in result.errors:
+            ...         print(err.short())
+        """
+        return _run_coro_sync(
+            self.executor.deep_validate(definition, fixtures=fixtures, timeout=timeout)
+        )
+
     def run(
         self,
         definition: Dict[str, Any],
@@ -105,19 +167,21 @@ class ProgramGarden:
                 resource_limits=limits,
                 storage_dir=storage_dir,
             )
-            
+
             if wait:
-                # Wait for completion
-                import asyncio
-                start_time = asyncio.get_event_loop().time() if timeout else None
+                # Wait for completion. Use the running loop's clock (get_running_loop
+                # is always valid here — we are inside the coroutine) rather than
+                # get_event_loop, which is deprecated and loop-state sensitive.
+                loop = asyncio.get_running_loop()
+                start_time = loop.time() if timeout else None
                 while job.status in ("pending", "running"):
                     await asyncio.sleep(0.1)
-                    if timeout and asyncio.get_event_loop().time() - start_time > timeout:
+                    if timeout and loop.time() - start_time > timeout:
                         break
-            
+
             return job.get_state()
 
-        return asyncio.run(_run())
+        return _run_coro_sync(_run())
 
     async def run_async(
         self,

{programgarden-1.22.4 → programgarden-1.23.1}/programgarden/context.py

@@ -257,6 +257,13 @@ class ExecutionContext:
         # Shutdown flag: cleanup 진행 중/완료 시 실시간 콜백 차단
         self._shutdown: bool = False
 
+        # deep_validate: unresolved {{ }} bindings collected during the virtual
+        # full-execution pass. Each entry: {"node_id", "expression", "reason"}.
+        # Drained by `executor.deep_validate` into DEEP_VALIDATION_BINDING_UNRESOLVED
+        # errors. Only populated in deep mode (runtime/dry_run keep the old
+        # warn-and-continue behaviour untouched).
+        self._deep_unresolved_bindings: List[Dict[str, str]] = []
+
         self._build_dag_index(workflow_edges, workflow_nodes)
 
     # === Storage Directory ===
@@ -289,14 +296,74 @@ class ExecutionContext:
 
     @property
     def is_dry_run(self) -> bool:
-        """Workflow is running in dry_run mode.
+        """Workflow is running in dry_run mode (deep_validate is a superset).
 
         When True, side-effectful nodes (주문/Realtime/알림) skip external calls
         and return simulated responses. Query/백테스트 nodes still execute normally.
 
-        Enable via ``context_params={"dry_run": True}`` in ``pg.run_async``.
+        deep_validate is a strict superset of dry_run: enabling ``deep_validate``
+        turns this True so every existing dry_run guard (order simulation, event
+        loop skip, position/risk tracker skip, MESSAGING simulation, SQL write
+        block) fires automatically — there is no order/notify path that reaches a
+        real broker call in deep mode.
+
+        Enable via ``context_params={"dry_run": True}`` (or
+        ``{"deep_validate": True}``) in ``pg.run_async``.
         """
-        return bool(self.context_params.get("dry_run", False))
+        return bool(
+            self.context_params.get("dry_run", False)
+            or self.context_params.get("deep_validate", False)
+        )
+
+    @property
+    def is_deep_validate(self) -> bool:
+        """Workflow is running in deep_validate (virtual full-execution) mode.
+
+        Deep validate is the strict-blocking ``deep_validate`` superset of
+        dry_run. This property is True ONLY for deep mode (not plain dry_run), so
+        executors can take the deep-only branch: inject fixture data for
+        realtime/data nodes (so the flow completes without waiting for events
+        that never arrive) and accumulate per-node errors instead of aborting on
+        the first failure.
+
+        Enable via ``context_params={"deep_validate": True}``.
+        """
+        return bool(self.context_params.get("deep_validate", False))
+
+    def get_deep_fixture(self, node_id: str, node_type: str) -> Optional[Dict[str, Any]]:
+        """Return a caller-supplied deep-validate fixture override, if any.
+
+        Callers may pass ``context_params={"deep_fixtures": {key: {...}}}`` where
+        ``key`` is either a node id or a node type. Node id takes precedence over
+        node type. Returns None when no override exists (executor then uses its
+        own schema-based default fixture).
+        """
+        fixtures = self.context_params.get("deep_fixtures")
+        if not isinstance(fixtures, dict):
+            return None
+        override = fixtures.get(node_id)
+        if override is None:
+            override = fixtures.get(node_type)
+        return override if isinstance(override, dict) else None
+
+    def record_deep_unresolved_binding(self, node_id: str, expression: str, reason: str) -> None:
+        """Record a ``{{ }}`` binding that could not be evaluated during a
+        deep_validate pass. No-op outside deep mode so runtime/dry_run are
+        unaffected. Deduplicated on (node_id, expression) so an auto-iterate that
+        re-evaluates the same literal N times yields a single entry.
+        """
+        if not self.is_deep_validate:
+            return
+        for entry in self._deep_unresolved_bindings:
+            if entry.get("node_id") == node_id and entry.get("expression") == expression:
+                return
+        self._deep_unresolved_bindings.append(
+            {"node_id": node_id, "expression": expression, "reason": reason}
+        )
+
+    def get_deep_unresolved_bindings(self) -> List[Dict[str, str]]:
+        """Return the deduplicated unresolved-binding records gathered in deep mode."""
+        return list(self._deep_unresolved_bindings)
 
     # === DAG Index Building ===
 
@@ -1567,6 +1634,10 @@ class ExecutionContext:
         data_schema: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Notify all listeners about display data from DisplayNode."""
+        # dry_run/deep_validate: suppress outbound display notifications centrally
+        # (no listener side-effects during virtual validation runs).
+        if self.is_dry_run:
+            return
         logger.debug(f"📡 notify_display_data: {node_id} ({chart_type})")
 
         if not self._listeners:
@@ -1612,6 +1683,9 @@ class ExecutionContext:
 
     async def notify_llm_stream(self, event: LLMStreamEvent) -> None:
         """LLM 토큰 스트리밍 이벤트 전파. UI 실시간 타이핑 효과용."""
+        # dry_run/deep_validate: suppress outbound stream notifications centrally.
+        if self.is_dry_run:
+            return
         if not self._listeners:
             return
         for listener in self._listeners:
@@ -1623,6 +1697,9 @@ class ExecutionContext:
 
     async def notify_token_usage(self, event: TokenUsageEvent) -> None:
         """토큰 사용량 이벤트 전파. 비용 추적 및 모니터링용."""
+        # dry_run/deep_validate: suppress outbound token-usage notifications.
+        if self.is_dry_run:
+            return
         if not self._listeners:
             return
         for listener in self._listeners:
@@ -1634,6 +1711,9 @@ class ExecutionContext:
 
     async def notify_ai_tool_call(self, event: AIToolCallEvent) -> None:
         """AI Tool 호출 이벤트 전파. UI에서 Tool 호출 상태 표시용."""
+        # dry_run/deep_validate: suppress outbound tool-call notifications.
+        if self.is_dry_run:
+            return
         if not self._listeners:
             return
         for listener in self._listeners:
@@ -1727,6 +1807,12 @@ class ExecutionContext:
         data: Optional[Dict[str, Any]] = None,
     ) -> None:
         """편의 메서드: NotificationEvent 생성 및 전파."""
+        # dry_run/deep_validate: suppress outbound notifications centrally so no
+        # external messaging (telegram/kakao/AI) is dispatched during a virtual
+        # validation run. Covers workflow lifecycle (started/completed/failed) and
+        # all convenience-method emitters in one place.
+        if self.is_dry_run:
+            return
         event = NotificationEvent(
             job_id=self.job_id,
             category=category,

programgarden-1.23.1/programgarden/deep_fixtures.py

@@ -0,0 +1,374 @@
+"""Deep-validate fixture generators (virtual full-execution).
+
+`deep_validate` runs a workflow once, end-to-end, without touching the broker
+network or placing any real order. Realtime / data-fetch nodes that would
+normally wait for live events or hit the LS API instead return a *fixture* — a
+schema-shaped default payload — so the flow keeps flowing to downstream nodes
+and field/type/flow integrity can be checked.
+
+Every generator here is pure and synchronous: it derives a reasonable default
+from the node config (mostly the requested symbols), never performs I/O, and
+matches the node's real output port shape so downstream consumers see the same
+keys they would at runtime.
+
+Callers may override any fixture via
+``context_params={"deep_fixtures": {node_id_or_type: {...}}}``; that override is
+applied by the executor (``context.get_deep_fixture``) *before* falling back to
+these defaults.
+
+All user-facing strings in this module must be English.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+
+
+# A single deterministic "as-of" date for fixture time series, so deep runs are
+# reproducible and do not depend on wall-clock during a validation pass.
+_FIXTURE_ANCHOR = datetime(2025, 1, 2, tzinfo=timezone.utc)
+
+
+def _norm_symbols(raw: Any) -> List[Dict[str, str]]:
+    """Normalise a symbols input into ``[{"symbol", "exchange"}]``.
+
+    Accepts the shapes the executors accept: a list of strings, a list of
+    ``{"symbol", "exchange"}`` dicts, or a single such dict. Returns at least one
+    entry (a placeholder) so a fixture is always non-empty — an empty list would
+    let an unrelated "no symbols" error mask the integrity check.
+    """
+    out: List[Dict[str, str]] = []
+    if isinstance(raw, dict):
+        raw = [raw]
+    if isinstance(raw, list):
+        for entry in raw:
+            if isinstance(entry, dict):
+                sym = str(entry.get("symbol", "") or "").strip()
+                exch = str(entry.get("exchange", "") or "").strip()
+                if sym:
+                    out.append({"symbol": sym, "exchange": exch or "NASDAQ"})
+            elif isinstance(entry, str) and entry.strip():
+                out.append({"symbol": entry.strip(), "exchange": "NASDAQ"})
+    if not out:
+        out.append({"symbol": "AAPL", "exchange": "NASDAQ"})
+    return out
+
+
+def _config_symbols(config: Dict[str, Any]) -> Any:
+    """Best-effort symbols extraction from a node config (no context I/O)."""
+    for key in ("symbols", "symbol"):
+        if config.get(key):
+            return config[key]
+    return None
+
+
+# Number of OHLCV bars every fixture time-series carries. Must comfortably
+# exceed the lookback of common indicators (RSI(14), Bollinger(20), SR windows,
+# ATR(14), TSMOM(60)) so a deep run computes a *real* (non-None / non-neutral)
+# indicator value instead of a "data too short" sentinel — a thin series was the
+# Phase 1 source of deep-validate false positives. Capped to keep the single
+# deep pass fast (it runs every condition plugin over every symbol within a hard
+# 15 s box); a handful of corpus indicators use a longer lookback (e.g. calmar
+# 252) and legitimately fall back to a neutral value — that does not break flow.
+_FIXTURE_BARS = 64
+
+
+def _ohlcv_series(symbol: str, *, n: int = _FIXTURE_BARS, base: float = 100.0) -> 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
+    final bar. That gives indicators something non-trivial to chew on (a real RSI
+    in the 25–75 band, a real Bollinger position, a real ATR) rather than a
+    perfectly monotonic ramp that pins RSI to 0/100. The shape is *deterministic*
+    (no randomness) so deep runs stay reproducible.
+    """
+    bars: List[Dict[str, Any]] = []
+    peak = int(n * 0.65)
+    price = base
+    for i in range(n):
+        day = _FIXTURE_ANCHOR + timedelta(days=i)
+        # Rise toward the peak, then ease back down — a gentle mean-reverting arc.
+        if i <= peak:
+            price = base + i * 0.8
+        else:
+            price = base + peak * 0.8 - (i - peak) * 1.1
+        price = max(price, base * 0.5)
+        bars.append(
+            {
+                "date": day.strftime("%Y%m%d"),
+                "open": round(price - 0.5, 2),
+                "high": round(price + 1.0, 2),
+                "low": round(price - 1.0, 2),
+                "close": round(price, 2),
+                "volume": 1_000_000 + i * 1000,
+            }
+        )
+    return bars
+
+
+def _time_series_entries(config: Dict[str, Any], symbols_raw: Any = 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
+    (``symbol``/``exchange``) plus a ``time_series`` of OHLCV bars.
+    """
+    syms = _norm_symbols(symbols_raw if symbols_raw is not None else _config_symbols(config))
+    entries: List[Dict[str, Any]] = []
+    for idx, entry in enumerate(syms):
+        entries.append(
+            {
+                "symbol": entry["symbol"],
+                "exchange": entry["exchange"],
+                "time_series": _ohlcv_series(entry["symbol"], base=100.0 + idx * 10),
+            }
+        )
+    return entries
+
+
+def real_market_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+    """RealMarketDataNode deep fixture.
+
+    Real shape: ``{"symbols", "ohlcv_data": {SYM: [bars]}, "data": {SYM: [bars]}}``.
+    """
+    syms = _norm_symbols(symbols_raw if symbols_raw is not None else _config_symbols(config))
+    ohlcv: Dict[str, List[Dict[str, Any]]] = {}
+    for idx, entry in enumerate(syms):
+        ohlcv[entry["symbol"]] = _ohlcv_series(entry["symbol"], base=100.0 + idx * 10)
+    return {
+        "symbols": syms,
+        "ohlcv_data": ohlcv,
+        "data": dict(ohlcv),
+    }
+
+
+def market_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+    """MarketDataNode (REST current-price) deep fixture.
+
+    Real shape: ``{"values": [{symbol, exchange, price, change, change_pct,
+    volume, open, high, low, close, per, eps}]}``.
+    """
+    syms = _norm_symbols(symbols_raw if symbols_raw is not None else _config_symbols(config))
+    values: List[Dict[str, Any]] = []
+    for idx, entry in enumerate(syms):
+        price = round(100.0 + idx * 10, 2)
+        values.append(
+            {
+                "symbol": entry["symbol"],
+                "exchange": entry["exchange"],
+                "price": price,
+                "change": 1.0,
+                "change_pct": 1.0,
+                "volume": 1_000_000,
+                "open": round(price - 0.5, 2),
+                "high": round(price + 1.0, 2),
+                "low": round(price - 1.0, 2),
+                "close": price,
+                "per": 15.0,
+                "eps": 5.0,
+            }
+        )
+    return {"values": values}
+
+
+def historical_data_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+    """HistoricalDataNode deep fixture.
+
+    Real shape (executor.py ``HistoricalDataNodeExecutor.execute`` return):
+    ``{"value": {symbol, exchange, time_series:[bars]} | None,
+        "values": [{symbol, exchange, time_series:[bars]}, ...],
+        "symbols": [str, ...], "period": str, "interval": str}``.
+
+    Each ``time_series`` bar is ``{date, open, high, low, close, volume}``.
+    Downstream ConditionNode auto-iterates ``values`` and reads
+    ``item.time_series`` / ``item.symbol``, so this shape must mirror the runtime
+    output exactly (the prior ``ohlcv_data`` map shape silently starved the
+    ConditionNode and produced deep false positives).
+    """
+    if symbols_raw is None:
+        symbols_raw = config.get("symbol") or _config_symbols(config)
+    entries = _time_series_entries(config, symbols_raw)
+    single = entries[0] if len(entries) == 1 else None
+    return {
+        "value": single,
+        "values": entries,
+        "symbols": [e["symbol"] for e in entries],
+        "period": str(config.get("period", "1d")),
+        "interval": str(config.get("interval", config.get("period", "1d"))),
+    }
+
+
+def _fixture_balance(currency: str = "USD") -> Dict[str, Any]:
+    """Per-currency balance map (RealAccountNode shape) + flat convenience keys.
+
+    Mirrors the real RealAccountNode balance: a currency-keyed map plus a
+    ``_summary``. Also carries flat keys (``orderable_amount``, ``total_pnl_rate``)
+    that PositionSizingNode / IfNode aggregate checks read directly, so neither
+    consumer shape sees a missing field in deep mode.
+    """
+    return {
+        currency: {
+            "deposit": 100000.0,
+            "orderable_amount": 100000.0,
+            "eval_amount": 105000.0,
+            "pnl_amount": 5000.0,
+            "pnl_rate": 5.0,
+        },
+        "_summary": {
+            "total_deposit": 100000.0,
+            "total_eval_amount": 105000.0,
+            "total_pnl_amount": 5000.0,
+        },
+        # Flat convenience keys some consumers (PositionSizing, aggregate IfNode)
+        # read directly.
+        "cash": 100000.0,
+        "total_value": 105000.0,
+        "orderable_amount": 100000.0,
+        "total_pnl_rate": 5.0,
+    }
+
+
+def _fixture_positions(config: Dict[str, Any], symbols_raw: Any = None) -> List[Dict[str, Any]]:
+    """Held positions fixture mirroring the real Account/RealAccount position dict.
+
+    The FIRST position is deliberately *losing* (negative pnl_rate) so per-position
+    risk conditions (StopLoss / TrailingStop) trigger during a deep run — a flat
+    "everything is +5%" book would never exercise the stop-loss → order → notify
+    branch, leaving its ``{{ item.* }}`` bindings unreached (a false negative).
+    """
+    syms = _norm_symbols(symbols_raw if symbols_raw is not None else _config_symbols(config))
+    positions: List[Dict[str, Any]] = []
+    for idx, entry in enumerate(syms):
+        avg = round(100.0 + idx * 10, 2)
+        # First holding is underwater (-8%), the rest are in profit (+5%).
+        cur = round(avg * 0.92, 2) if idx == 0 else round(avg * 1.05, 2)
+        qty = 10
+        positions.append(
+            {
+                "symbol": entry["symbol"],
+                "exchange": entry["exchange"],
+                "name": entry["symbol"],
+                "qty": qty,
+                "quantity": qty,  # NewOrderNode compat key
+                "direction": "long",
+                "close_side": "sell",
+                "avg_price": avg,
+                "entry_price": avg,
+                "current_price": cur,
+                "price": cur,
+                "pnl_rate": round((cur - avg) / avg * 100, 2),
+                "pnl_amount": round((cur - avg) * qty, 2),
+                "eval_amount": round(cur * qty, 2),
+                "purchase_amount": round(avg * qty, 2),
+                "currency": "USD",
+                "market": entry["exchange"],
+                "market_code": "82",
+            }
+        )
+    return positions
+
+
+def real_account_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+    """RealAccountNode deep fixture.
+
+    Real shape: ``{"positions": [...], "balance": {...}, "open_orders": {}}``.
+    """
+    return {
+        "positions": _fixture_positions(config, symbols_raw),
+        "balance": _fixture_balance(),
+        "open_orders": {},
+    }
+
+
+def account_fixture(config: Dict[str, Any], symbols_raw: Any = None) -> Dict[str, Any]:
+    """AccountNode (REST) deep fixture.
+
+    Real shape: ``{"positions": [...], "balance": {...}}``.
+    """
+    return {
+        "positions": _fixture_positions(config, symbols_raw),
+        "balance": _fixture_balance(),
+    }
+
+
+def open_orders_fixture(config: Dict[str, Any]) -> Dict[str, Any]:
+    """OpenOrdersNode deep fixture (no pending orders — real LS query blocked).
+
+    Real shape: ``{"open_orders": [...], "count": N}``.
+    """
+    return {"open_orders": [], "count": 0}
+
+
+def real_order_event_fixture(config: Dict[str, Any]) -> Dict[str, Any]:
+    """RealOrderEventNode deep fixture (one simulated fill).
+
+    Real shape includes a ``filled`` payload + ``status`` field.
+    """
+    ts = _FIXTURE_ANCHOR.isoformat()
+    return {
+        "status": "체결",
+        "filled": {
+            "timestamp": ts,
+            "symbol": "AAPL",
+            "order_no": "DEEP-0001",
+            "side": "buy",
+            "order_qty": 10,
+            "order_price": 100.0,
+            "status": "체결",
+        },
+    }
+
+
+def market_status_fixture(config: Dict[str, Any]) -> Dict[str, Any]:
+    """MarketStatusNode deep fixture (markets open).
+
+    Real shape: ``{"statuses": [{market, status}]}``.
+    """
+    return {
+        "statuses": [
+            {"market": "NASDAQ", "status": "OPEN"},
+            {"market": "NYSE", "status": "OPEN"},
+        ],
+    }
+
+
+def broker_connection_fixture(
+    node_type: str,
+    config: Dict[str, Any],
+) -> Dict[str, Any]:
+    """BrokerNode deep fixture connection (no LS login, no fill-price sync).
+
+    Mirrors the real success shape ``{"connected": True, "connection": {...}}``
+    so downstream nodes that read ``connection`` (broker auto-injection) keep
+    flowing. Credentials are placeholders — every downstream broker-bound node is
+    itself short-circuited in deep mode, so they are never used for a real call.
+    """
+    if "Futures" in node_type:
+        product = "overseas_futures"
+    elif "Korea" in node_type:
+        product = "korea_stock"
+    else:
+        product = config.get("product", "overseas_stock")
+    paper_trading = bool(config.get("paper_trading", False)) if product != "korea_stock" else False
+    return {
+        "connected": True,
+        "connection": {
+            "provider": config.get("provider", "ls-sec.co.kr"),
+            "product": product,
+            "paper_trading": paper_trading,
+            "appkey": "DEEP_VALIDATE_APPKEY",
+            "appsecret": "DEEP_VALIDATE_APPSECRET",
+        },
+    }
+
+
+def apply_override(default: Dict[str, Any], override: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    """Shallow-merge a caller override on top of a default fixture.
+
+    Override keys win; unspecified keys keep the schema-shaped default so the
+    flow still has every output port populated.
+    """
+    if not override:
+        return default
+    merged = dict(default)
+    merged.update(override)
+    return merged