programgarden 1.29.0__tar.gz → 1.29.2__tar.gz

{programgarden-1.29.0 → programgarden-1.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.29.0
+Version: 1.29.2
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

{programgarden-1.29.0 → programgarden-1.29.2}/programgarden/executor.py

@@ -54,6 +54,28 @@ _RESERVED_ITERATION_ROOTS: frozenset = frozenset({"item", "row"})
 
 _INLINE_EXPR_PATTERN = re.compile(r"\{\{\s*(.+?)\s*\}\}")
 
+# Realtime (event-source) node types — the ONE list. Three separate lifecycle
+# decisions key off it: (1) whether the job enters the event loop (and so keeps
+# the WebSocket subscriptions alive instead of tearing them down in `finally`),
+# (2) whether the node auto-triggers its downstream chain on each event, and
+# (3) whether it is skipped on re-execution (it is already running).
+#
+# It used to be copy-pasted at all three sites, and the Korea family — added
+# later — was never added to any of them. Result: Korea realtime workflows had
+# no event source, so the job completed immediately, cleanup closed the socket,
+# and ticks never reached the table. Keep this the single source of truth;
+# `test_realtime_node_types_cover_declarations` fails if a node declares
+# `stay_connected` but is missing here.
+REALTIME_NODE_TYPES: frozenset = frozenset({
+    "RealAccountNode", "RealMarketDataNode", "RealOrderEventNode",
+    "OverseasStockRealAccountNode", "OverseasStockRealMarketDataNode",
+    "OverseasStockRealOrderEventNode",
+    "OverseasFuturesRealAccountNode", "OverseasFuturesRealMarketDataNode",
+    "OverseasFuturesRealOrderEventNode",
+    "KoreaStockRealAccountNode", "KoreaStockRealMarketDataNode",
+    "KoreaStockRealOrderEventNode",
+})
+
 
 def _free_root_names(text: str) -> Set[str]:
     """Return the set of free-variable root identifiers referenced (ctx=Load) by
@@ -736,8 +758,14 @@ class ThrottleNodeExecutor(NodeExecutorBase):
         interval_sec = config.get("interval_sec", 5.0)
         pass_first = config.get("pass_first", True)
 
-        # State key for this node
+        # State key for this node.
+        # Split 분기 안에서는 종목마다 별도 스코프를 쓴다. 노드 하나를 분기 아이템들이
+        # 공유하므로, 스코프가 없으면 쿨다운까지 공유돼 한 사이클에 한 종목만 통과하고
+        # 나머지 종목은 매번 버려진다(표에 종목당 1행이 안 나온다).
         state_key = "_throttle_state"
+        branch_scope = config.get("_branch_scope")
+        if branch_scope:
+            state_key = f"{state_key}:{branch_scope}"
         throttle_state = context.get_node_state(node_id, state_key) or {
             "last_passed_at": None,
             "skipped_count": 0,
@@ -930,7 +958,18 @@ class ThrottleNodeExecutor(NodeExecutorBase):
                             for key, value in all_outputs.items():
                                 if not key.startswith("_"):
                                     input_data[key] = value
-        
+
+        # 상류 출력은 모든 실행 경로(메인 플로우/Split 분기/실시간 재실행)가 이미
+        # `_input_<node_id>` 의사 노드에 모아둔다. 위의 `context._workflow_edges` 워크는
+        # **프로덕션에서 그 속성을 아무도 설정하지 않아** 통째로 죽어 있었다(테스트만 주입).
+        # 그래서 ThrottleNode 는 실시간 핸들러가 `_realtime_data` 를 직접 꽂아주는 경로에서만
+        # 동작했고, Split 분기 안에서는 상류에 실시간 시세가 흘러도 영원히 빈 입력을 봤다
+        # → 영원히 cooldown → 분기 결과가 전부 버려져 Aggregate 표가 안 찼다.
+        upstream = context.get_all_outputs(f"_input_{node_id}") or {}
+        for key, value in upstream.items():
+            if not key.startswith("_"):
+                input_data.setdefault(key, value)
+
         return input_data
 
 
@@ -989,6 +1028,104 @@ def _public_outputs(outputs: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
+# ── Split 분기 × 실시간 시세: 종목별 분리 (2026-07-14) ────────────────────────
+# 실시간 시세 노드는 **노드 하나에 구독 종목이 전부 합쳐진** symbol-keyed 출력을 낸다
+# (`ohlcv_data = {"005930": [bar], "000660": [bar]}` — on_tick 이 종목별 bar 를 한 dict 에
+# 누적). 그런데 Split 분기의 아이템 하나는 자기 종목만 봐야 한다. 자르지 않으면 모든
+# 분기가 같은 덩어리를 보고 같은 값을 수집해 "종목당 1행" 표가 나오지 않는다.
+_SYMBOL_ITEM_KEYS = ("symbol", "shcode", "code")
+
+# Split 분기가 수집할 값을 고를 때 payload 로 인정하는 포트(선언 순). 예전엔 공개 포트
+# 중 **아무거나 첫 번째**(dict 순서 의존)를 집어서, 시세 노드가 `symbols` 를 먼저 쓰면
+# 가격 대신 종목코드 목록이 표에 실렸다(비결정 + 잘못된 데이터).
+_BRANCH_PAYLOAD_PORTS = ("result", "value", "data", "ohlcv_data")
+
+# 실시간 노드가 어떤 분기 스코프(종목)까지 구독을 걸었는지 기록하는 node_state 키.
+# 종목마다 최초 1회만 실행하고, 틱마다의 분기 재구동에선 건너뛴다(재구독 폭주 방지).
+_SUBSCRIBED_SCOPES_KEY = "_subscribed_branch_scopes"
+
+
+def _item_symbol(item: Any) -> Optional[str]:
+    """Split 아이템에서 종목코드를 뽑는다 ('005930' 또는 {'symbol': '005930'})."""
+    if isinstance(item, str):
+        return item or None
+    if isinstance(item, dict):
+        for key in _SYMBOL_ITEM_KEYS:
+            value = item.get(key)
+            if isinstance(value, str) and value:
+                return value
+    return None
+
+
+def _is_symbol_keyed_payload(value: Any) -> bool:
+    """`{"005930": [bar], "000660": [bar]}` 처럼 종목코드로 키가 잡힌 시세 payload 인가."""
+    return (
+        isinstance(value, dict)
+        and bool(value)
+        and all(isinstance(v, list) for v in value.values())
+    )
+
+
+def _slice_realtime_outputs(outputs: Dict[str, Any], symbol: str) -> Dict[str, Any]:
+    """실시간 시세 노드의 합쳐진 출력을 한 종목 몫으로 자른다.
+
+    **이 종목의 틱이 아직 없으면 공개 포트를 하나도 내지 않는다**(내부 `_` 포트만 남긴다).
+    빈 값이나 `symbols` 목록만 내보내면 Throttle 이 "흘릴 데이터가 있다"고 착각해 통과시키고,
+    표에 **가격 없는 행**이 낀다. 실제로 HKEX 라이브에서 아직 체결이 없던 2번째 종목이
+    합쳐진 덩어리를 그대로 행으로 실어 이 결함이 드러났다(2026-07-14).
+    """
+    meta = {
+        k: v for k, v in outputs.items()
+        if isinstance(k, str) and k.startswith("_")
+    }
+    payload: Dict[str, Any] = {}
+    has_payload = False
+
+    for port, value in outputs.items():
+        if isinstance(port, str) and port.startswith("_"):
+            continue
+        if _is_symbol_keyed_payload(value):
+            if symbol in value:
+                payload[port] = value[symbol]
+                has_payload = True
+            # 이 종목 몫이 없으면 그 포트는 **아예 내지 않는다** (덩어리 통과 금지)
+            continue
+        if port == "symbol":
+            payload[port] = symbol
+            continue
+        if port == "symbols" and isinstance(value, list):
+            payload[port] = [s for s in value if _item_symbol(s) == symbol]
+            continue
+        payload[port] = value
+
+    if not has_payload:
+        return meta
+    return {**meta, **payload}
+
+
+def _realtime_branch_row(public: Dict[str, Any], symbol: Optional[str]) -> Optional[Dict[str, Any]]:
+    """실시간 분기 아이템이 표에 기여할 **평평한 한 행**을 만든다.
+
+    슬라이스된 payload 는 이 종목의 bar 리스트(`[{date, open, high, low, close, volume}]`)
+    이므로, 최신 bar 에 종목코드를 붙여 `{symbol, date, open, ..., volume}` 한 행으로 낸다.
+    TableDisplayNode 는 평평한 dict 의 리스트를 기대한다(첫 행의 키가 곧 표의 열).
+    """
+    for port in ("data", "ohlcv_data"):
+        value = public.get(port)
+        bar = None
+        if isinstance(value, list) and value and isinstance(value[-1], dict):
+            bar = value[-1]
+        elif isinstance(value, dict) and value and not isinstance(next(iter(value.values()), None), (dict, list)):
+            bar = value
+        if bar is None:
+            continue
+        row = dict(bar)
+        if symbol:
+            row.setdefault("symbol", symbol)
+        return row
+    return None
+
+
 # ── 해외주식 거래소 표기 정규화 (2026-07-14 결함3) ────────────────────────────
 # LS 는 거래소를 갈래마다 다른 표현으로 준다: REST balance(COSOQ00201) MktTpNm 은
 # 한글 표시명('뉴욕'/'나스닥'), FcurrMktCode 는 LS 코드('81'/'82'/'83'), screener/
@@ -17523,12 +17660,7 @@ class WorkflowJob:
         result = []
         for node_id, node in self.workflow.nodes.items():
             # 실시간 노드 (stay_connected 설정)
-            if node.node_type in (
-                "RealAccountNode", "RealMarketDataNode", "RealOrderEventNode",
-                "OverseasStockRealAccountNode", "OverseasFuturesRealAccountNode",
-                "OverseasStockRealMarketDataNode", "OverseasFuturesRealMarketDataNode",
-                "OverseasStockRealOrderEventNode", "OverseasFuturesRealOrderEventNode",
-            ):
+            if node.node_type in REALTIME_NODE_TYPES:
                 if node.config.get("stay_connected", True):
                     result.append(node_id)
             # 영속 노드 (백그라운드 태스크를 등록하는 노드)
@@ -18609,7 +18741,7 @@ class WorkflowJob:
             return
 
         total = len(input_array)
-        collected_results: List[Any] = []
+        results_by_index: Dict[int, Any] = {}
         errors: List[str] = []
 
         print(f"    📦 SplitNode: {total} items, parallel={parallel}, delay_ms={delay_ms}")
@@ -18618,7 +18750,7 @@ class WorkflowJob:
         if parallel:
             # Parallel execution
             async def execute_item(idx: int, item: Any) -> Any:
-                return await self._execute_branch_for_item(
+                return idx, await self._execute_branch_for_item(
                     split_id=split_id,
                     branch_order=branch_order,
                     item=item,
@@ -18629,32 +18761,28 @@ class WorkflowJob:
             tasks = [execute_item(i, item) for i, item in enumerate(input_array)]
             for coro in asyncio.as_completed(tasks):
                 try:
-                    result = await coro
-                    if result is not _SKIP_BRANCH_ITEM:
-                        collected_results.append(result)
+                    idx, result = await coro
+                    results_by_index[idx] = result
                 except Exception as e:
                     if continue_on_error:
                         errors.append(str(e))
-                        collected_results.append(None)
                     else:
                         raise
         else:
             # Sequential execution
             for idx, item in enumerate(input_array):
                 try:
-                    result = await self._execute_branch_for_item(
+                    results_by_index[idx] = await self._execute_branch_for_item(
                         split_id=split_id,
                         branch_order=branch_order,
                         item=item,
                         index=idx,
                         total=total,
                     )
-                    if result is not _SKIP_BRANCH_ITEM:
-                        collected_results.append(result)
                 except Exception as e:
                     if continue_on_error:
                         errors.append(str(e))
-                        collected_results.append(None)
+                        results_by_index[idx] = None
                     else:
                         raise
 
@@ -18662,6 +18790,34 @@ class WorkflowJob:
                 if delay_ms > 0 and idx < total - 1:
                     await asyncio.sleep(delay_ms / 1000)
 
+        # === Collect, holding the last known row per item (realtime branches) ===
+        # 실시간 분기는 틱마다 재구동되고 ThrottleNode 는 종목별 쿨다운으로 대부분의
+        # 사이클을 막는다. 통과하지 못한 종목을 그냥 버리면 수집 배열이 사이클마다
+        # 통째로 비어 **표가 깜빡인다**(찼다 → 빈 표 → 찼다). 이번 사이클에 새 값이 없으면
+        # 그 종목의 **직전 행을 유지**한다. 실시간이 아닌 분기는 기존대로 버린다
+        # (아직 실데이터가 없는 아이템을 표에 끼우지 않기 위함 — 2026-07-14 결함2).
+        realtime_branch = any(
+            (self.workflow.nodes.get(n).node_type in REALTIME_NODE_TYPES)
+            for n in branch_order
+            if self.workflow.nodes.get(n)
+        )
+        held_key = "_last_branch_rows"
+        held: Dict[str, Any] = dict(self.context.get_node_state(aggregate_id, held_key) or {})
+
+        collected_results: List[Any] = []
+        for idx in range(total):
+            result = results_by_index.get(idx, _SKIP_BRANCH_ITEM)
+            if result is _SKIP_BRANCH_ITEM:
+                if realtime_branch and str(idx) in held:
+                    collected_results.append(held[str(idx)])
+                continue
+            collected_results.append(result)
+            if realtime_branch and result is not None:
+                held[str(idx)] = result
+
+        if realtime_branch:
+            self.context.set_node_state(aggregate_id, held_key, held)
+
         # === Store results for AggregateNode ===
         self.context.set_node_state(aggregate_id, "_collected_items", collected_results)
 
@@ -18716,21 +18872,60 @@ class WorkflowJob:
         result = item
         last_had_public = None  # None = branch 노드 없음 / True|False = 마지막 노드 결과
 
+        # 이 분기가 실시간 시세를 다루는가 + 이 아이템의 종목은 무엇인가.
+        # (실시간 분기에서만 종목별 슬라이싱/행 생성을 적용해 파장을 그 경우로 가둔다.)
+        symbol = _item_symbol(item)
+        realtime_branch = any(
+            (self.workflow.nodes.get(n).node_type in REALTIME_NODE_TYPES)
+            for n in branch_order
+            if self.workflow.nodes.get(n)
+        )
+        # 분기 아이템마다 독립된 상태 스코프. ThrottleNode 의 쿨다운은 노드별 상태라
+        # 종목들이 한 노드를 공유하면 대기시간까지 공유돼 한 번에 한 종목만 통과한다.
+        branch_scope = f"{split_id}#{index}"
+
         # Execute each branch node
         for node_id in branch_order:
             node = self.workflow.nodes.get(node_id)
             if not node:
                 continue
 
+            is_realtime = node.node_type in REALTIME_NODE_TYPES
+            subscribed: List[str] = []
+            if is_realtime:
+                # 실시간 노드는 **분기 아이템(종목)마다 최초 1회는 반드시 실행**해야 한다
+                # — 그래야 그 종목의 구독이 걸린다. 그 뒤(틱마다의 분기 재구동)엔 실행하지
+                # 않는다: 재실행하면 틱마다 재구독이 걸려 소켓이 폭주한다. 최신 시세는 틱
+                # 콜백이 이 노드의 context 출력에 계속 갱신해 두므로 하류는 그걸 읽으면 된다.
+                #
+                # ⚠️ 예전엔 "출력이 있으면 스킵"으로 판단했는데, 첫 종목이 실행되며 출력을
+                # 남기는 순간 **2번째 이후 종목의 최초 구독까지 건너뛰어** 그 종목엔 시세가
+                # 영영 오지 않았다(HKEX 라이브에서 2번째 종목이 통째로 死, 2026-07-14).
+                subscribed = list(
+                    self.context.get_node_state(node_id, _SUBSCRIBED_SCOPES_KEY) or []
+                )
+                if branch_scope in subscribed:
+                    continue
+
             # Prepare config
             config = dict(node.config)
             config = self._resolve_config_expressions(config, node_id)
             config = self._auto_inject_connection(node_id, node, config)
+            config["_branch_scope"] = branch_scope
 
             # Connect inputs from upstream
             for edge in self.workflow.edges:
                 if edge.to_node_id == node_id:
                     all_outputs = self.context.get_all_outputs(edge.from_node_id)
+                    source = self.workflow.nodes.get(edge.from_node_id)
+                    if (
+                        all_outputs
+                        and symbol
+                        and source
+                        and source.node_type in REALTIME_NODE_TYPES
+                    ):
+                        # 합쳐진 시세를 이 아이템의 종목 몫으로 자른다
+                        all_outputs = _slice_realtime_outputs(all_outputs, symbol)
                     for port_name, port_value in all_outputs.items():
                         self.context.set_output(f"_input_{node_id}", port_name, port_value)
 
@@ -18749,13 +18944,31 @@ class WorkflowJob:
             for port_name, value in outputs.items():
                 self.context.set_output(node_id, port_name, value)
 
+            if is_realtime:
+                # 이 종목 구독 완료 — 다음 재구동부터는 이 노드를 건너뛴다
+                subscribed.append(branch_scope)
+                self.context.set_node_state(node_id, _SUBSCRIBED_SCOPES_KEY, subscribed)
+
             # Track last result — only from PUBLIC ports. Internal meta
             # (_throttle_stats 등)이 유일 출력일 때 그걸 결과로 집으면 Aggregate/Display
             # 가 내부 통계를 데이터로 렌더한다.
             public = _public_outputs(outputs) if outputs else {}
             last_had_public = bool(public)
             if public:
-                result = public.get("result") or public.get("value") or next(iter(public.values()), item)
+                if realtime_branch:
+                    row = _realtime_branch_row(public, symbol)
+                    if row is None:
+                        # 실시간 분기인데 가격 payload 가 없다(예: symbols 목록만 남음)
+                        # → 이 아이템은 표에 기여할 실데이터가 없다 → skip.
+                        # 그러지 않으면 가격 없는 행이 '실시간 체결가' 표에 낀다.
+                        last_had_public = False
+                    else:
+                        result = row
+                else:
+                    result = next(
+                        (public[p] for p in _BRANCH_PAYLOAD_PORTS if public.get(p) is not None),
+                        next(iter(public.values()), item),
+                    )
 
         # 마지막 branch 노드가 공개 출력을 전혀 못 냈으면(예: ThrottleNode 가 이번 사이클
         # 을 throttling 중이라 내부 메타만 반환) 이 아이템은 기여할 실데이터가 없다 →
@@ -18835,13 +19048,7 @@ class WorkflowJob:
         source_node = self.workflow.nodes.get(source_node_id)
         
         # 실시간 노드는 하위 노드를 자동 트리거
-        auto_trigger_types = {
-            "RealAccountNode", "RealMarketDataNode", "RealOrderEventNode",
-            "OverseasStockRealAccountNode", "OverseasFuturesRealAccountNode",
-            "OverseasStockRealMarketDataNode", "OverseasFuturesRealMarketDataNode",
-            "OverseasStockRealOrderEventNode", "OverseasFuturesRealOrderEventNode",
-        }
-        is_realtime_source = source_node and source_node.node_type in auto_trigger_types
+        is_realtime_source = source_node and source_node.node_type in REALTIME_NODE_TYPES
         
         for edge in self.workflow.edges:
             if edge.from_node_id == source_node_id:
@@ -19269,24 +19476,42 @@ class WorkflowJob:
         # 🆕 트리거된 노드들 + 하위 노드들을 모두 찾아서 실행 순서대로 정렬
         nodes_to_execute = self._find_downstream_nodes(trigger_nodes)
         print(f"  → 실행할 노드 체인: {nodes_to_execute}")
-        
+
+        # Split→Aggregate 분기는 노드를 하나씩 재실행해서는 절대 채워지지 않는다.
+        # AggregateNode 의 유일한 입력인 node_state["_collected_items"] 를 쓰는 곳은
+        # _execute_split_branch 한 곳뿐이라, 틱이 하류만 일반 재실행하면 수집 배열이
+        # 최초 실행 시점 값(대개 [])에 영구히 얼어붙는다 → 표가 영원히 빈 채로 남는다.
+        # 체인이 분기에 닿으면 그 Split 분기를 통째로 재구동해 수집을 다시 채운다.
+        split_pairs = self._find_split_aggregate_pairs()
+        chain = set(nodes_to_execute)
+        branch_driven: Set[str] = set()
+        for split_id, aggregate_id in split_pairs.items():
+            branch = self._get_branch_nodes(split_id, aggregate_id)
+            if not (chain & branch) and aggregate_id not in chain:
+                continue
+            split_node = self.workflow.nodes.get(split_id)
+            if not split_node:
+                continue
+            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}
+
         for node_id in nodes_to_execute:
             if not self.context.is_running:
                 break
-            
+
             node = self.workflow.nodes.get(node_id)
             if not node:
                 continue
-            
+
             # 실시간 노드는 이미 실행 중이므로 스킵 (무한 루프 방지)
-            if node.node_type in (
-                "RealAccountNode", "RealMarketDataNode", "RealOrderEventNode",
-                "OverseasStockRealAccountNode", "OverseasFuturesRealAccountNode",
-                "OverseasStockRealMarketDataNode", "OverseasFuturesRealMarketDataNode",
-                "OverseasStockRealOrderEventNode", "OverseasFuturesRealOrderEventNode",
-            ):
+            if node.node_type in REALTIME_NODE_TYPES:
                 continue
-            
+
+            # 분기 재구동이 이미 실행한 노드는 중복 실행하지 않는다
+            if node_id in branch_driven:
+                continue
+
             # Re-execute the triggered node
             try:
                 print(f"    ▶ Re-executing: {node_id} ({node.node_type})")

{programgarden-1.29.0 → programgarden-1.29.2}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.29.0"
+version = "1.29.2"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"