programgarden 1.29.3__tar.gz → 1.30.0__tar.gz

{programgarden-1.29.3 → programgarden-1.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.29.3
+Version: 1.30.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -16,7 +16,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.11,<2.0.0)
-Requires-Dist: programgarden-core (>=1.21.0,<2.0.0)
+Requires-Dist: programgarden-core (>=1.22.0,<2.0.0)
 Requires-Dist: programgarden-finance (>=1.6.14,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)

{programgarden-1.29.3 → programgarden-1.30.0}/programgarden/executor.py

@@ -15,6 +15,7 @@ import ast
 import re
 import uuid
 import logging
+import sys
 
 from programgarden.resolver import WorkflowResolver, ResolvedWorkflow, ValidationResult
 from programgarden_core import (
@@ -42,6 +43,44 @@ from programgarden_core.nodes.base import BaseMessagingNode
 logger = logging.getLogger("programgarden.executor")
 
 
+def _safe_print(*args: Any, **kwargs: Any) -> None:
+    """Emit console output without ever letting it abort the caller.
+
+    Console output is a side effect — a workflow must never die because a log
+    line could not be rendered. On a console whose encoding cannot represent
+    the text (cp949 on Korean Windows is the case we hit), a bare ``print``
+    raises ``UnicodeEncodeError``. Two things make that fatal rather than
+    cosmetic:
+
+    1. The progress line at the head of ``_execute_main_flow`` runs before any
+       node does, so the whole job dies before it starts.
+    2. The same call pattern sits inside ``except`` blocks, so the *reporting*
+       path raises too and the original cause is swallowed — the failure never
+       reaches ``notify_job_state`` and vanishes silently.
+
+    Note that ASCII-only literals are not sufficient protection: interpolated
+    values (node names, exception messages) can themselves carry characters the
+    console cannot encode. So every print in this module goes through here.
+    """
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        # Re-render through the stream's own encoding so the line still lands,
+        # with unrepresentable characters replaced rather than the job lost.
+        try:
+            stream = kwargs.get("file") or sys.stdout
+            encoding = getattr(stream, "encoding", None) or "ascii"
+            sep = kwargs.get("sep", " ")
+            end = kwargs.get("end", "\n")
+            text = sep.join(str(a) for a in args) + end
+            stream.write(text.encode(encoding, errors="replace").decode(encoding, errors="replace"))
+        except Exception:
+            logger.debug("console output dropped", exc_info=True)
+    except Exception:
+        # Logging is never load-bearing.
+        logger.debug("console output dropped", exc_info=True)
+
+
 # lib reserved iteration variable roots — valid ONLY mid-iteration.
 # `{{ item.* }}` (auto-iterate per-item) and `{{ row.* }}` (ConditionNode
 # items.extract) only resolve while the executor has an iteration context set;
@@ -1086,10 +1125,22 @@ def _pick_split_array(upstream: Dict[str, Any], *, source: str) -> List[Any]:
     if len(candidates) == 1:
         return upstream[candidates[0]]
     if not candidates:
+        # ⑰ Diagnostic: a singular alias (value → values, item → items) present
+        # where the plural array port was meant is a common wrong-key mistake;
+        # surface it in the error so the fix is obvious (report-only — resolution
+        # is unchanged, the two ports legitimately co-exist).
+        _alias_hint = ""
+        for _sing, _plur in (("value", "values"), ("item", "items")):
+            if _sing in upstream and _plur not in upstream:
+                _alias_hint = (
+                    f" Upstream has '{_sing}' (singular) but no '{_plur}' (array) "
+                    f"— did you mean '{_plur}'?"
+                )
+                break
         raise RuntimeError(
             f"SplitNode has no array to split: upstream ({source}) exposes no "
-            f"array output among {_SPLIT_ARRAY_KEYS}. Bind split.array explicitly "
-            "(e.g. array: '{{ nodes.<id>.held_symbols }}') or wire an "
+            f"array output among {_SPLIT_ARRAY_KEYS}.{_alias_hint} Bind split.array "
+            "explicitly (e.g. array: '{{ nodes.<id>.held_symbols }}') or wire an "
             "array-producing node upstream."
         )
     raise RuntimeError(
@@ -1509,10 +1560,26 @@ class ScheduleNodeExecutor(NodeExecutorBase):
             context.log("debug", f"Scheduler already running for {node_id}, skip", node_id)
             return {"trigger": True}
         
-        cron_expr = config.get("cron", "*/5 * * * *")
+        # ⑭ cron is required — NO silent "*/5 * * * *" fallback. A missing cron
+        # used to make the schedule quietly run every 5 minutes ("looks fine,
+        # behaves differently"). Fail loudly instead so the real cause surfaces.
+        cron_expr = config.get("cron")
+        if not isinstance(cron_expr, str) or not cron_expr.strip():
+            context.log(
+                "error",
+                "ScheduleNode requires a 'cron' expression; there is no default schedule fallback",
+                node_id,
+            )
+            raise ValueError(
+                f"ScheduleNode '{node_id}' requires a 'cron' expression; there is no "
+                f"default schedule fallback. Set cron explicitly, e.g. '*/5 * * * *' "
+                f"(every 5 min) or '30 9 * * 1-5' (09:30 weekdays). Keys like "
+                f"'mode'/'schedule' are not read by this node."
+            )
+        cron_expr = cron_expr.strip()
         tz_name = config.get("timezone", "America/New_York")
         enabled = config.get("enabled", True)
-        count = config.get("count", 1000)  # 최대 반복 횟수 (M-6: 기본값 축소)
+        count = config.get("count", 1000)  # 최대 반복 횟수 (M-6: 기본값 축소; 모델 필드로 편입)
         max_duration_hours = config.get("max_duration_hours", 24.0)
         
         if not enabled:
@@ -8396,8 +8463,8 @@ class DisplayNodeExecutor(NodeExecutorBase):
         
         if chart_type == "summary":
             # Raw JSON 표시
-            print(f"\n📋 {title or 'Data Summary'} [{now}]")
-            print("=" * 60)
+            _safe_print(f"\n📋 {title or 'Data Summary'} [{now}]")
+            _safe_print("=" * 60)
             try:
                 def serialize(obj):
                     if hasattr(obj, 'model_dump'):
@@ -8411,11 +8478,11 @@ class DisplayNodeExecutor(NodeExecutorBase):
                     return obj
                 
                 serialized = serialize(data)
-                print(json.dumps(serialized, indent=2, ensure_ascii=False, default=str))
+                _safe_print(json.dumps(serialized, indent=2, ensure_ascii=False, default=str))
             except Exception as e:
-                print(f"(직렬화 실패: {e})")
-                print(str(data)[:500])
-            print("=" * 60 + "\n")
+                _safe_print(f"(직렬화 실패: {e})")
+                _safe_print(str(data)[:500])
+            _safe_print("=" * 60 + "\n")
             
             output_data["data"] = data
             
@@ -8426,8 +8493,8 @@ class DisplayNodeExecutor(NodeExecutorBase):
             sort_by = config.get("sort_by")
             sort_order = config.get("sort_order", "desc")
             
-            print(f"\n📊 {title or 'Table'} [{now}]")
-            print("=" * 80)
+            _safe_print(f"\n📊 {title or 'Table'} [{now}]")
+            _safe_print("=" * 80)
             
             # 데이터 형식 판단
             if isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict):
@@ -8441,13 +8508,13 @@ class DisplayNodeExecutor(NodeExecutorBase):
                     (k, k) for k in list(rows[0].keys())[:8]
                 ]
                 header = " | ".join(f"{label:<12}" for _, label in cols)
-                print(header)
-                print("-" * 80)
+                _safe_print(header)
+                _safe_print("-" * 80)
                 for row in rows:
                     values = " | ".join(
                         f"{self._format_value(row.get(key)):<12}" for key, _ in cols
                     )
-                    print(values)
+                    _safe_print(values)
                     
             elif isinstance(data, dict):
                 # dict of dicts (symbol: {field: value}) 또는 flat dict
@@ -8463,19 +8530,19 @@ class DisplayNodeExecutor(NodeExecutorBase):
                             (k, k) for k in list(items[0][1].keys())[:6]
                         ]
                         header = f"{'Key':<12} | " + " | ".join(f"{label:<12}" for _, label in cols)
-                        print(header)
-                        print("-" * 80)
+                        _safe_print(header)
+                        _safe_print("-" * 80)
                         for key, val in items:
                             values = f"{key:<12} | " + " | ".join(
                                 f"{self._format_value(val.get(col_key)):<12}" for col_key, _ in cols
                             )
-                            print(values)
+                            _safe_print(values)
                 else:
                     # flat dict
                     for k, v in list(data.items())[:limit]:
-                        print(f"  {k:<25}: {self._format_value(v)}")
+                        _safe_print(f"  {k:<25}: {self._format_value(v)}")
             
-            print("=" * 80 + "\n")
+            _safe_print("=" * 80 + "\n")
             output_data["data"] = data
             
         elif chart_type == "line":
@@ -8489,36 +8556,36 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"line 차트에 x_field, y_field 필수", node_id)
                 return {"rendered": False, "error": "x_field, y_field 필수"}
             
-            print(f"\n📈 {title or 'Line Chart'} [{now}]")
-            print("=" * 60)
+            _safe_print(f"\n📈 {title or 'Line Chart'} [{now}]")
+            _safe_print("=" * 60)
             
             if isinstance(data, list) and len(data) > 0:
                 first = data[0]
                 last = data[-1]
-                print(f"📊 데이터 포인트: {len(data)}개")
-                print(f"📅 X축 범위: {first.get(x_field)} ~ {last.get(x_field)}")
-                print(f"📈 Y축({y_field}) 시작: {self._format_value(first.get(y_field))}")
-                print(f"📈 Y축({y_field}) 끝: {self._format_value(last.get(y_field))}")
+                _safe_print(f"📊 데이터 포인트: {len(data)}개")
+                _safe_print(f"📅 X축 범위: {first.get(x_field)} ~ {last.get(x_field)}")
+                _safe_print(f"📈 Y축({y_field}) 시작: {self._format_value(first.get(y_field))}")
+                _safe_print(f"📈 Y축({y_field}) 끝: {self._format_value(last.get(y_field))}")
                 
                 # 최대/최소
                 values = [d.get(y_field, 0) for d in data if d.get(y_field) is not None]
                 if values:
-                    print(f"📈 최대: {self._format_value(max(values))}")
-                    print(f"📉 최소: {self._format_value(min(values))}")
+                    _safe_print(f"📈 최대: {self._format_value(max(values))}")
+                    _safe_print(f"📉 최소: {self._format_value(min(values))}")
                 
                 # 시그널 마커 표시
                 if signal_field:
                     signals = self._extract_signals(data, x_field, signal_field, side_field)
                     if signals:
-                        print(f"\n🎯 시그널 ({len(signals)}개):")
+                        _safe_print(f"\n🎯 시그널 ({len(signals)}개):")
                         for sig in signals[:10]:  # 최대 10개만 표시
-                            print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
+                            _safe_print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
                         if len(signals) > 10:
-                            print(f"  ... 외 {len(signals) - 10}개")
+                            _safe_print(f"  ... 외 {len(signals) - 10}개")
             else:
-                print("(데이터 없음)")
+                _safe_print("(데이터 없음)")
             
-            print("=" * 60 + "\n")
+            _safe_print("=" * 60 + "\n")
             output_data["data"] = data
             output_data["x_field"] = x_field
             output_data["y_field"] = y_field
@@ -8542,8 +8609,8 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"multi_line 차트에 x_field, y_field, series_key 필수", node_id)
                 return {"rendered": False, "error": "x_field, y_field, series_key 필수"}
             
-            print(f"\n📈 {title or 'Multi-Line Chart'} [{now}]")
-            print("=" * 80)
+            _safe_print(f"\n📈 {title or 'Multi-Line Chart'} [{now}]")
+            _safe_print("=" * 80)
             
             # data가 평탄화된 배열 형식인 경우 [{symbol, date, value, ...}, ...]
             if isinstance(data, list):
@@ -8568,29 +8635,29 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 
                 series_items = series_items[:limit]
                 
-                print(f"📊 시리즈 수: {len(series_items)}개 (limit: {limit})")
-                print("-" * 80)
-                print(f"{'Series':<12} | {'Points':<8} | {f'First {y_field}':<15} | {f'Last {y_field}':<15}")
-                print("-" * 80)
+                _safe_print(f"📊 시리즈 수: {len(series_items)}개 (limit: {limit})")
+                _safe_print("-" * 80)
+                _safe_print(f"{'Series':<12} | {'Points':<8} | {f'First {y_field}':<15} | {f'Last {y_field}':<15}")
+                _safe_print("-" * 80)
                 
                 for symbol, rows in series_items:
                     if isinstance(rows, list) and len(rows) > 0:
                         first_val = rows[0].get(y_field, 0)
                         last_val = rows[-1].get(y_field, 0)
-                        print(f"{symbol:<12} | {len(rows):<8} | {self._format_value(first_val):<15} | {self._format_value(last_val):<15}")
+                        _safe_print(f"{symbol:<12} | {len(rows):<8} | {self._format_value(first_val):<15} | {self._format_value(last_val):<15}")
                 
                 # 시그널 마커 표시
                 if signal_field:
                     signals = self._extract_signals(data, x_field, signal_field, side_field, series_key)
                     if signals:
-                        print(f"\n🎯 시그널 ({len(signals)}개):")
+                        _safe_print(f"\n🎯 시그널 ({len(signals)}개):")
                         for sig in signals[:15]:  # 최대 15개만 표시
                             series_info = f" [{sig.get('series', '')}]" if sig.get('series') else ""
-                            print(f"  {sig['marker']} {sig['x']}{series_info} ({sig['signal']}/{sig['side']})")
+                            _safe_print(f"  {sig['marker']} {sig['x']}{series_info} ({sig['signal']}/{sig['side']})")
                         if len(signals) > 15:
-                            print(f"  ... 외 {len(signals) - 15}개")
+                            _safe_print(f"  ... 외 {len(signals) - 15}개")
             
-            print("=" * 80 + "\n")
+            _safe_print("=" * 80 + "\n")
             output_data["data"] = data
             output_data["x_field"] = x_field
             output_data["y_field"] = y_field
@@ -8616,16 +8683,16 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"candlestick 차트에 date_field, open_field, high_field, low_field, close_field 필수", node_id)
                 return {"rendered": False, "error": "OHLC 필드 필수"}
             
-            print(f"\n📊 {title or 'Candlestick Chart'} [{now}]")
-            print("=" * 80)
+            _safe_print(f"\n📊 {title or 'Candlestick Chart'} [{now}]")
+            _safe_print("=" * 80)
             
             if isinstance(data, list) and len(data) > 0:
                 first = data[0]
                 last = data[-1]
-                print(f"📊 캔들 수: {len(data)}개")
-                print(f"📅 기간: {first.get(date_field)} ~ {last.get(date_field)}")
-                print(f"💵 시작 종가: {self._format_value(first.get(close_field))}")
-                print(f"💵 최종 종가: {self._format_value(last.get(close_field))}")
+                _safe_print(f"📊 캔들 수: {len(data)}개")
+                _safe_print(f"📅 기간: {first.get(date_field)} ~ {last.get(date_field)}")
+                _safe_print(f"💵 시작 종가: {self._format_value(first.get(close_field))}")
+                _safe_print(f"💵 최종 종가: {self._format_value(last.get(close_field))}")
                 
                 # 수익률
                 start_price = first.get(close_field, 0)
@@ -8634,21 +8701,21 @@ class DisplayNodeExecutor(NodeExecutorBase):
                     pct_change = (end_price - start_price) / start_price * 100
                     sign = "+" if pct_change >= 0 else ""
                     color = "\033[92m" if pct_change >= 0 else "\033[91m"
-                    print(f"📈 변동률: {color}{sign}{pct_change:.2f}%\033[0m")
+                    _safe_print(f"📈 변동률: {color}{sign}{pct_change:.2f}%\033[0m")
                 
                 # 시그널 마커 표시
                 if signal_field:
                     signals = self._extract_signals(data, date_field, signal_field, side_field)
                     if signals:
-                        print(f"\n🎯 시그널 ({len(signals)}개):")
+                        _safe_print(f"\n🎯 시그널 ({len(signals)}개):")
                         for sig in signals[:10]:  # 최대 10개만 표시
-                            print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
+                            _safe_print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
                         if len(signals) > 10:
-                            print(f"  ... 외 {len(signals) - 10}개")
+                            _safe_print(f"  ... 외 {len(signals) - 10}개")
             else:
-                print("(데이터 없음)")
+                _safe_print("(데이터 없음)")
             
-            print("=" * 80 + "\n")
+            _safe_print("=" * 80 + "\n")
             output_data["data"] = data
             output_data["date_field"] = date_field
             output_data["open_field"] = open_field
@@ -8671,23 +8738,23 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"bar 차트에 x_field, y_field 필수", node_id)
                 return {"rendered": False, "error": "x_field, y_field 필수"}
             
-            print(f"\n📊 {title or 'Bar Chart'} [{now}]")
-            print("=" * 60)
+            _safe_print(f"\n📊 {title or 'Bar Chart'} [{now}]")
+            _safe_print("=" * 60)
             
             if isinstance(data, list) and len(data) > 0:
-                print(f"{'Bar':<20} | {y_field}")
-                print("-" * 60)
+                _safe_print(f"{'Bar':<20} | {y_field}")
+                _safe_print("-" * 60)
                 for item in data[:20]:
                     x_val = item.get(x_field, "")
                     y_val = item.get(y_field, 0)
-                    print(f"{str(x_val):<20} | {self._format_value(y_val)}")
+                    _safe_print(f"{str(x_val):<20} | {self._format_value(y_val)}")
             elif isinstance(data, dict):
-                print(f"{'Key':<20} | {'Value'}")
-                print("-" * 60)
+                _safe_print(f"{'Key':<20} | {'Value'}")
+                _safe_print("-" * 60)
                 for k, v in list(data.items())[:20]:
-                    print(f"{str(k):<20} | {self._format_value(v)}")
+                    _safe_print(f"{str(k):<20} | {self._format_value(v)}")
             
-            print("=" * 60 + "\n")
+            _safe_print("=" * 60 + "\n")
             output_data["data"] = data
             output_data["x_field"] = x_field
             output_data["y_field"] = y_field
@@ -10555,7 +10622,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             except (ValueError, _json.JSONDecodeError):
                 pass
 
-        # 우선순위: config.symbol > input.symbol
+        # 우선순위: config.symbol > input.symbol > config.symbols (수동 목록 폴백)
         if config_symbol:
             symbols_raw = [config_symbol] if isinstance(config_symbol, dict) else []
             context.log("debug", f"Using config.symbol: {config_symbol}", node_id)
@@ -10563,7 +10630,23 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             symbols_raw = [input_symbol] if isinstance(input_symbol, dict) else []
             context.log("debug", f"Using input port symbol: {input_symbol}", node_id)
         else:
-            symbols_raw = []
+            # 마지막 폴백: config.symbols (복수 리터럴 목록) — MarketDataNodeExecutor 의
+            # config_symbols 폴백과 대칭. 상류 배열 입력은 메인 루프 auto-iterate 가
+            # 단수 input.symbol 로 풀어 위 분기에서 소화되므로, 여기 도달하는 건
+            # 리터럴 목록뿐이라 N² 재조회 우려가 없다. deep_validate 픽스처는 이미
+            # _config_symbols() 로 plural 을 읽어 라이브만 조용히 무시하던 비대칭이었다
+            # (실측: code-node 예제 87~93 이 심볼 3개를 적고도 빈 ohlcv 로 사망).
+            config_symbols = config.get("symbols")
+            if isinstance(config_symbols, list):
+                symbols_raw = [e for e in config_symbols if isinstance(e, (dict, str))]
+                if symbols_raw:
+                    context.log(
+                        "debug",
+                        f"Using config.symbols list: {len(symbols_raw)} entries",
+                        node_id,
+                    )
+            else:
+                symbols_raw = []
         
         # symbols 정규화: [{exchange, symbol}] → 문자열 리스트 + exchange 정보 보존
         symbols = []
@@ -12347,7 +12430,21 @@ class PositionSizingNodeExecutor(NodeExecutorBase):
         price_data = evaluated.get("price_data") or evaluated.get("prices") or evaluated.get("market_data") or {}
         
         # 설정 추출
-        method = evaluated.get("method", "fixed_percent")
+        # ⑰ method is required — NO silent "fixed_percent" fallback. The old
+        # default quietly confirmed a hallucinated key (e.g. size_type:"fixed"
+        # left method unset → sized as fixed_percent). Fail loudly instead.
+        method = evaluated.get("method")
+        if not method:
+            context.log(
+                "error",
+                "PositionSizingNode requires 'method'; there is no default fallback",
+                node_id,
+            )
+            raise ValueError(
+                f"PositionSizingNode '{node_id}' requires 'method' (one of "
+                f"fixed_percent, fixed_amount, fixed_quantity, kelly, atr_based); "
+                f"there is no default. A key like 'size_type' is not read by this node."
+            )
         max_percent = float(evaluated.get("max_percent", 10.0))
         fixed_amount = evaluated.get("fixed_amount")
         fixed_quantity = int(evaluated.get("fixed_quantity", 1))
@@ -18203,7 +18300,7 @@ class WorkflowJob:
         except asyncio.CancelledError:
             self.status = "cancelled"
             logger.info(f"Job {self.job_id} cancelled")
-            print(f"⚠️ Job {self.job_id} cancelled")
+            _safe_print(f"[CANCELLED] Job {self.job_id} cancelled")
             await self.context.notify_job_state("cancelled", self.stats)
         except Exception as e:
             self.status = "failed"
@@ -18220,9 +18317,17 @@ class WorkflowJob:
                 }
             self.context.log("error", error_msg)
             logger.exception(f"Job {self.job_id} failed: {e}")
-            print(f"❌ Job {self.job_id} failed: {e}")
+            # ASCII-only marker: this is the failure-reporting path, so it must
+            # survive a console that could not render the text that failed.
+            _safe_print(f"[FAILED] Job {self.job_id} failed: {e}")
             import traceback
-            traceback.print_exc()
+            try:
+                # print_exc renders the offending source line, which may itself
+                # hold the character that could not be encoded — so it can raise
+                # the very error it is reporting.
+                traceback.print_exc()
+            except Exception:
+                logger.debug("traceback output dropped", exc_info=True)
             await self.context.notify_job_state("failed", self.stats)
 
             # WORKFLOW_FAILED notification
@@ -18296,7 +18401,7 @@ class WorkflowJob:
             skip_nodes: 복구 모드에서 이미 완료된 노드 ID 집합 (스킵)
         """
         skip_nodes = skip_nodes or set()
-        print(f"🔄 Executing main flow: {self.workflow.execution_order}")
+        _safe_print(f"🔄 Executing main flow: {self.workflow.execution_order}")
 
         # === Item-based execution setup ===
         # Find Split/Aggregate pairs and their branch nodes
@@ -18336,7 +18441,7 @@ class WorkflowJob:
 
             # === Checkpoint restore: 이미 완료된 노드 스킵 ===
             if node_id in skip_nodes:
-                print(f"  ⏭ Skipping restored node: {node_id} ({node.node_type})")
+                _safe_print(f"  ⏭ Skipping restored node: {node_id} ({node.node_type})")
                 self._completed_node_ids.add(node_id)
                 await self.context.notify_node_state(
                     node_id=node_id,
@@ -18347,7 +18452,7 @@ class WorkflowJob:
 
             # === Item-based execution: Skip branch nodes (handled by SplitNode) ===
             if node_id in branch_nodes and node.node_type not in ("SplitNode", "AggregateNode"):
-                print(f"  ⏭ Skipping branch node: {node_id} (handled by SplitNode)")
+                _safe_print(f"  ⏭ Skipping branch node: {node_id} (handled by SplitNode)")
                 continue
 
             # === Item-based execution: Handle SplitNode specially ===
@@ -18358,12 +18463,12 @@ class WorkflowJob:
 
             # === Item-based execution: Skip AggregateNode (already executed by SplitNode) ===
             if node.node_type == "AggregateNode" and node_id in split_aggregate_pairs.values():
-                print(f"  ⏭ Skipping AggregateNode: {node_id} (already executed by SplitNode)")
+                _safe_print(f"  ⏭ Skipping AggregateNode: {node_id} (already executed by SplitNode)")
                 continue
 
             # === IfNode: 비활성 브랜치 스킵 ===
             if node_id in if_skipped_nodes:
-                print(f"  ⏭ Skipping node: {node_id} (IfNode branch not taken)")
+                _safe_print(f"  ⏭ Skipping node: {node_id} (IfNode branch not taken)")
                 await self.context.notify_node_state(
                     node_id=node_id,
                     node_type=node.node_type,
@@ -18371,7 +18476,7 @@ class WorkflowJob:
                 )
                 continue
 
-            print(f"  ▶ Executing node: {node_id} ({node.node_type})")
+            _safe_print(f"  ▶ Executing node: {node_id} ({node.node_type})")
             
             # 🆕 노드 실행 시작 알림
             start_time = datetime.utcnow()
@@ -18542,7 +18647,7 @@ class WorkflowJob:
                     new_skips = self._compute_if_skip_nodes(node_id, taken)
                     if_skipped_nodes.update(new_skips)
                     if new_skips:
-                        print(f"  🔀 IfNode {node_id}: branch={taken}, skipping {new_skips}")
+                        _safe_print(f"  🔀 IfNode {node_id}: branch={taken}, skipping {new_skips}")
 
                 # deep_validate: a node that *returns* a sole-`error` dict (rather
                 # than raising) would otherwise be stored as a COMPLETED output and
@@ -18843,7 +18948,7 @@ class WorkflowJob:
         all_results = []
         total = len(items)
 
-        print(f"  🔄 Auto-iterate: {node_id} ({node.node_type}) - {total} items")
+        _safe_print(f"  🔄 Auto-iterate: {node_id} ({node.node_type}) - {total} items")
 
         for idx, current_item in enumerate(items):
             # === item, index, total을 ExecutionContext에 설정 ===
@@ -18854,7 +18959,7 @@ class WorkflowJob:
 
             # 진행 상황 로그
             item_label = current_item.get("symbol", str(current_item)) if isinstance(current_item, dict) else str(current_item)
-            print(f"    [{idx+1}/{total}] Processing: {item_label}")
+            _safe_print(f"    [{idx+1}/{total}] Processing: {item_label}")
             self.context.log("debug", f"Auto-iterate [{idx+1}/{total}]: {item_label}", node_id)
 
             # A-3: per-item spacing for order / external-API nodes
@@ -18887,7 +18992,7 @@ class WorkflowJob:
 
         # 결과 병합: 배열 필드는 병합, 단일 필드는 마지막 값
         merged = self._merge_iterate_results(all_results)
-        print(f"  ✅ Auto-iterate complete: {len(all_results)} results merged")
+        _safe_print(f"  ✅ Auto-iterate complete: {len(all_results)} results merged")
 
         return merged
 
@@ -19081,7 +19186,7 @@ class WorkflowJob:
         """
         from programgarden_core.bases.listener import NodeState
 
-        print(f"  🔀 Executing SplitNode branch: {split_id}")
+        _safe_print(f"  🔀 Executing SplitNode branch: {split_id}")
 
         # Get paired AggregateNode
         aggregate_id = split_aggregate_pairs.get(split_id)
@@ -19170,7 +19275,7 @@ class WorkflowJob:
         results_by_index: Dict[int, Any] = {}
         errors: List[str] = []
 
-        print(f"    📦 SplitNode: {total} items, parallel={parallel}, delay_ms={delay_ms}")
+        _safe_print(f"    📦 SplitNode: {total} items, parallel={parallel}, delay_ms={delay_ms}")
 
         # === Execute branch for each item ===
         if parallel:
@@ -19417,7 +19522,7 @@ class WorkflowJob:
         if not node:
             return
 
-        print(f"  🔗 Executing AggregateNode: {aggregate_id}")
+        _safe_print(f"  🔗 Executing AggregateNode: {aggregate_id}")
 
         start_time = datetime.utcnow()
         await self.context.notify_node_state(
@@ -19884,24 +19989,24 @@ class WorkflowJob:
         Follows topological order to ensure proper data flow.
         """
         from datetime import datetime
-        print(f"[{datetime.now().strftime('%H:%M:%S')}] 🔄 실시간 업데이트 이벤트 수신: trigger_nodes={event.trigger_nodes}")
+        _safe_print(f"[{datetime.now().strftime('%H:%M:%S')}] 🔄 실시간 업데이트 이벤트 수신: trigger_nodes={event.trigger_nodes}")
         
         # trigger_nodes가 비어있으면 source_node_id에서 연결된 하위 노드 찾기
         trigger_nodes = event.trigger_nodes
         if not trigger_nodes and event.source_node_id:
             trigger_nodes = self._find_trigger_nodes(event.source_node_id)
-            print(f"  → 자동 탐색된 trigger_nodes: {trigger_nodes}")
+            _safe_print(f"  → 자동 탐색된 trigger_nodes: {trigger_nodes}")
         
         if not trigger_nodes:
-            print(f"  ⚠️ 트리거할 노드 없음, 스킵")
+            _safe_print(f"  ⚠️ 트리거할 노드 없음, 스킵")
             return
         
         logger.debug(f"Realtime update from {event.source_node_id}, triggering: {trigger_nodes}")
-        print(f"  → {event.source_node_id}에서 트리거: {trigger_nodes}")
+        _safe_print(f"  → {event.source_node_id}에서 트리거: {trigger_nodes}")
         
         # 🆕 트리거된 노드들 + 하위 노드들을 모두 찾아서 실행 순서대로 정렬
         nodes_to_execute = self._find_downstream_nodes(trigger_nodes)
-        print(f"  → 실행할 노드 체인: {nodes_to_execute}")
+        _safe_print(f"  → 실행할 노드 체인: {nodes_to_execute}")
 
         # Split→Aggregate 분기는 노드를 하나씩 재실행해서는 절대 채워지지 않는다.
         # AggregateNode 의 유일한 입력인 node_state["_collected_items"] 를 쓰는 곳은
@@ -19918,7 +20023,7 @@ class WorkflowJob:
             split_node = self.workflow.nodes.get(split_id)
             if not split_node:
                 continue
-            print(f"    🔀 Re-driving split branch: {split_id} → {aggregate_id}")
+            _safe_print(f"    🔀 Re-driving split branch: {split_id} → {aggregate_id}")
             await self._execute_split_branch(split_id, split_node, split_pairs, branch)
             branch_driven |= branch | {split_id, aggregate_id}
 
@@ -19940,7 +20045,7 @@ class WorkflowJob:
 
             # Re-execute the triggered node
             try:
-                print(f"    ▶ Re-executing: {node_id} ({node.node_type})")
+                _safe_print(f"    ▶ Re-executing: {node_id} ({node.node_type})")
                 
                 # 소스 노드 ID를 config에 추가하여 최신 데이터 참조 가능하게
                 config_with_source = dict(node.config)
@@ -20120,7 +20225,17 @@ class WorkflowJob:
                     await self._task
                 except asyncio.CancelledError:
                     pass
-        
+
+        # Cleanup persistent trackers / flow-end nodes / broker·JIF 구독.
+        # 여태 stop() 은 이 정리를 빼먹어(cancel() 에만 있었다) 잡이 stop 으로 끝나면
+        # 계좌 추적기의 주기 폴링 루프가 취소되지 않고 무한히 LS 를 계속 조회했다(레이트
+        # 리밋·불필요 호출 유발). cleanup_* 는 끝에서 딕셔너리를 비우므로 _run 의 정상완료
+        # 경로가 먼저 정리했더라도 여기서 다시 불려도 빈 순회 = no-op(멱등).
+        await self._cleanup_broker_fill_subscriptions()
+        await self._cleanup_jif_subscriptions()
+        await self.context.cleanup_persistent_nodes()
+        await self.context.cleanup_flow_end_nodes()
+
         # Cleanup RiskTracker flush
         if self.context.risk_tracker:
             try:

{programgarden-1.29.3 → programgarden-1.30.0}/programgarden/semantic_rules.py

@@ -7,8 +7,8 @@ workflows that are still *semantically* wrong or *unsafe* — they validate
 *executability*, never *intent* or *safety*.
 
 The four ground-truth anti-patterns (verified against the canonical example
-workflows shipped in ``programgarden/examples/workflows`` and the live node
-registry):
+corpus — maintained internally since the 2026-08 privatization — and the live
+node registry):
 
   * **R1 — order quantity bound to an AIAgent response.** An AIAgent
     sentiment/decision output wired straight into an order quantity risks a
@@ -27,6 +27,15 @@ registry):
     Always trades the same size regardless of balance/risk. (Advisory.)
   * **R4 — order node carrying ``paper_trading``.** That field is a *broker*
     field; on an order node it is silently ignored. (Advisory.)
+  * **R5 — unknown node config key.** A key that is not in the node's
+    ``get_field_schema()`` nor its declared model fields. ``BaseNode`` sets
+    ``extra="allow"`` so Pydantic accepts it, and the executor never reads it —
+    the workflow *looks* configured but behaves differently (e.g. ScheduleNode
+    ``{mode, schedule}`` instead of ``cron`` → silent 5-min fallback;
+    PositionSizingNode ``size_type`` instead of ``method``). (Blocking when
+    enabled.) Structural, not keyword-based: the allowed set is derived from the
+    registry node class, and unknown / community / dynamic types (no resolvable
+    class) are skipped rather than false-flagged.
 
 Design contract
 ---------------
@@ -58,6 +67,7 @@ from programgarden_core import (
     ErrorLocation,
     ErrorSeverity,
     build_error,
+    suggest_close_match,
 )
 
 # ---------------------------------------------------------------------------
@@ -68,12 +78,14 @@ RULE_ORDER_QTY_FROM_AI = "order_qty_from_ai_response"            # R1
 RULE_STRUCTURED_OUTPUT_NO_SCHEMA = "structured_output_missing_schema"  # R2
 RULE_HARDCODED_ORDER_QTY = "hardcoded_order_quantity"            # R3
 RULE_ORDER_IGNORED_FIELD = "order_ignored_field"                # R4
+RULE_UNKNOWN_NODE_FIELD = "unknown_node_field"                  # R5
 
 ALL_RULES: tuple[str, ...] = (
     RULE_ORDER_QTY_FROM_AI,
     RULE_STRUCTURED_OUTPUT_NO_SCHEMA,
     RULE_HARDCODED_ORDER_QTY,
     RULE_ORDER_IGNORED_FIELD,
+    RULE_UNKNOWN_NODE_FIELD,
 )
 
 _RULE_CODE: Dict[str, ErrorCode] = {
@@ -81,18 +93,23 @@ _RULE_CODE: Dict[str, ErrorCode] = {
     RULE_STRUCTURED_OUTPUT_NO_SCHEMA: ErrorCode.SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA,
     RULE_HARDCODED_ORDER_QTY: ErrorCode.SEMANTIC_HARDCODED_ORDER_QTY,
     RULE_ORDER_IGNORED_FIELD: ErrorCode.SEMANTIC_ORDER_IGNORED_FIELD,
+    RULE_UNKNOWN_NODE_FIELD: ErrorCode.UNKNOWN_NODE_FIELD,
 }
 
 # Everything off — the default when no config is supplied.
 DEFAULT_SEMANTIC_SEVERITIES: Dict[str, str] = {r: "off" for r in ALL_RULES}
 
-# Chatbot strict preset — reproduces the legacy ``workflow_semantic_lint``
-# behavior exactly (R1/R2 block, R3/R4 advise). Callers opt in with this.
+# Chatbot strict preset — the save-chokepoint anti-pattern gate (R1/R2/R5
+# block, R3/R4 advise). R5 blocks hallucinated / typo'd node config keys
+# (e.g. ScheduleNode {mode,schedule} instead of cron, PositionSizingNode
+# size_type instead of method) that ``extra="allow"`` silently accepts — the
+# workflow looks configured but the extra keys are ignored at runtime.
 STRICT_SEMANTIC_SEVERITIES: Dict[str, str] = {
     RULE_ORDER_QTY_FROM_AI: "error",
     RULE_STRUCTURED_OUTPUT_NO_SCHEMA: "error",
     RULE_HARDCODED_ORDER_QTY: "warning",
     RULE_ORDER_IGNORED_FIELD: "warning",
+    RULE_UNKNOWN_NODE_FIELD: "error",
 }
 
 _SEVERITY_MAP: Dict[str, ErrorSeverity] = {
@@ -171,6 +188,47 @@ def _is_aiagent_node(node_type: Any) -> bool:
         return False
 
 
+# Structural keys present on every node dict but not always declared as a schema
+# / model field. ``config`` / ``description`` are BaseNode fields; ``plugin`` /
+# ``fields`` are the ConditionNode plugin-binding structure carried at node level.
+# ``credential_id`` is the canonical credential-binding key (``nodes[].credential_id``
+# + top-level ``credentials[]``): the executor's universal node-creation layer reads
+# it (``config.get("credential_id")`` → ``_inject_credentials``) for every node type,
+# so no per-node schema declares it — flagging it would block every credential-bound
+# workflow at the strict save gate.
+_RESERVED_NODE_KEYS: frozenset = frozenset(
+    {"id", "type", "category", "position", "config", "description", "plugin",
+     "fields", "credential_id"}
+)
+
+
+def _node_allowed_keys(node_type: Any) -> Optional[frozenset]:
+    """Allowed top-level config keys for a registered node type, or None.
+
+    The allowed set is the union of the node's declared Pydantic model fields,
+    its ``get_field_schema()`` keys (the AI/UI-facing schema), and the reserved
+    structural keys. Returns None when ``node_type`` does not resolve to a
+    registered class (unknown / community / dynamic) — R5 skips those, since
+    their schema is unknown and any key would otherwise be false-flagged.
+    Never raises.
+    """
+    cls = _node_class(node_type)
+    if cls is None:
+        return None
+    allowed = set(_RESERVED_NODE_KEYS)
+    try:
+        allowed |= set(cls.model_fields.keys())
+    except Exception:  # pragma: no cover - defensive
+        pass
+    try:
+        fs = cls.get_field_schema()
+        if isinstance(fs, dict):
+            allowed |= set(fs.keys())
+    except Exception:  # pragma: no cover - defensive
+        pass
+    return frozenset(allowed)
+
+
 # ---------------------------------------------------------------------------
 # Binding helpers
 # ---------------------------------------------------------------------------
@@ -261,6 +319,7 @@ def analyze_workflow_semantics(
     sev_r2 = _enabled(severities, RULE_STRUCTURED_OUTPUT_NO_SCHEMA)
     sev_r3 = _enabled(severities, RULE_HARDCODED_ORDER_QTY)
     sev_r4 = _enabled(severities, RULE_ORDER_IGNORED_FIELD)
+    sev_r5 = _enabled(severities, RULE_UNKNOWN_NODE_FIELD)
 
     # Index node id → node, and whether any PositionSizingNode exists (R3).
     nodes_by_id: Dict[str, Dict[str, Any]] = {}
@@ -282,6 +341,41 @@ def analyze_workflow_semantics(
         node_type = node.get("type")
         node_id = node.get("id") if isinstance(node.get("id"), str) else "?"
 
+        # ── R5: unknown node config key (hallucinated / typo'd field) ──────
+        # Runs for every node. Structural: the allowed set comes from the
+        # registry node class; unknown / dynamic types (allowed is None) are
+        # skipped rather than false-flagged.
+        if sev_r5 is not None:
+            allowed = _node_allowed_keys(node_type)
+            if allowed is not None:
+                for key in node.keys():
+                    if key in allowed:
+                        continue
+                    errors.append(build_error(
+                        ErrorCode.UNKNOWN_NODE_FIELD,
+                        f"Node '{node_id}' ({node_type}) has field '{key}', which is not "
+                        f"in this node's schema. Pydantic accepts it (extra='allow') but "
+                        f"the executor never reads it, so the workflow looks configured "
+                        f"but behaves differently than it appears.",
+                        severity=sev_r5,
+                        location=ErrorLocation(
+                            node_id=node_id,
+                            node_type=node_type if isinstance(node_type, str) else None,
+                            field_path=key if isinstance(key, str) else None,
+                        ),
+                        available_values=(
+                            suggest_close_match(key, sorted(allowed))
+                            if isinstance(key, str) else None
+                        ),
+                        suggestion=(
+                            f"'{key}' 는 {node_type} 노드에 없는 필드예요. 오탈자이거나 "
+                            f"다른 노드의 필드일 수 있습니다. 이 노드의 config_schema 에 "
+                            f"정의된 필드만 사용하세요 (예: ScheduleNode 는 cron, "
+                            f"PositionSizingNode 는 method)."
+                        ),
+                        details={"rule": RULE_UNKNOWN_NODE_FIELD, "field": key},
+                    ))
+
         # ── R2: AIAgent structured output with no schema (and no preset) ──
         if sev_r2 is not None and _is_aiagent_node(node_type):
             if node.get("output_format") == "structured":
@@ -396,6 +490,7 @@ __all__ = [
     "RULE_STRUCTURED_OUTPUT_NO_SCHEMA",
     "RULE_HARDCODED_ORDER_QTY",
     "RULE_ORDER_IGNORED_FIELD",
+    "RULE_UNKNOWN_NODE_FIELD",
     "ALL_RULES",
     "DEFAULT_SEMANTIC_SEVERITIES",
     "STRICT_SEMANTIC_SEVERITIES",

{programgarden-1.29.3 → programgarden-1.30.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.29.3"
+version = "1.30.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -29,7 +29,7 @@ lxml = "^6.0.2"
 pytickersymbols = {version = ">=1.17.5", python = ">=3.12,<4.0"}
 aiosqlite = "^0.20.0"
 litellm = ">=1.40.0"
-programgarden-core = "^1.21.0"
+programgarden-core = "^1.22.0"
 programgarden-finance = "^1.6.14"
 programgarden-community = "^1.13.11"