programgarden 1.35.0__tar.gz → 1.36.0__tar.gz

{programgarden-1.35.0 → programgarden-1.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.35.0
+Version: 1.36.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.15.0,<2.0.0)
-Requires-Dist: programgarden-core (>=1.26.0,<2.0.0)
+Requires-Dist: programgarden-core (>=1.28.0,<2.0.0)
 Requires-Dist: programgarden-finance (>=1.9.5,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)

{programgarden-1.35.0 → programgarden-1.36.0}/programgarden/context.py

@@ -11,7 +11,7 @@ Workflow execution context protocol
 
 from typing import Optional, Dict, Any, List, Protocol, runtime_checkable, Callable, Awaitable, TYPE_CHECKING, Tuple
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from collections import deque
 import asyncio
@@ -38,6 +38,7 @@ from programgarden_core.bases.listener import (
     LLMStreamEvent,
     TokenUsageEvent,
     AIToolCallEvent,
+    OrderFillEvent,
 )
 from programgarden_core.models.resilience import RetryEvent
 
@@ -2413,6 +2414,12 @@ class ExecutionContext:
             # 거래 모드 메타데이터 기록 (데이터 초기화 없이 모드만 업데이트)
             self._workflow_position_tracker.update_trading_mode(trading_mode)
 
+            # 체결 확정 → on_order_fill 리스너 연결. 즉시/버퍼/타임아웃 경로가
+            # 모두 원장의 단일 지점을 거치므로 여기서 한 번만 연결한다.
+            self._workflow_position_tracker.set_fill_classified_callback(
+                self._on_tracker_fill_classified
+            )
+
             # PnL refresh용 정보 저장
             self._workflow_broker_node_id = broker_node_id
             self._workflow_product = product
@@ -2683,6 +2690,72 @@ class ExecutionContext:
             logger.warning(f"Failed to record workflow fill: {e}")
             return "error"
 
+    async def _on_tracker_fill_classified(self, fill, classification: str) -> None:
+        """Bridge a newly recorded ledger fill to on_order_fill listeners.
+
+        The tracker invokes this exactly once per new fill — for immediate,
+        buffered, and timeout-resolved classifications alike — so notification
+        happens whether ``record_workflow_fill`` returned a final classification
+        or "pending" that only settled after the arrival-buffering timeout.
+        Facts only: no monetary computation. Manual/unknown_api/other fills have
+        no matching workflow order, so node_id stays None.
+        """
+        tracker = self._workflow_position_tracker
+        if tracker is None:
+            return
+
+        job_id = self.job_id
+        node_id = None
+        try:
+            identity = tracker.lookup_order_identity(fill.order_no, fill.order_date)
+            if identity is not None:
+                row_job_id, node_id = identity
+                if row_job_id:
+                    job_id = row_job_id
+        except Exception as e:
+            logger.warning(f"Failed to resolve order identity for fill: {e}")
+
+        received_at = getattr(fill, "received_at", None)
+        received_iso = (
+            received_at.isoformat() if hasattr(received_at, "isoformat")
+            else datetime.now(timezone.utc).isoformat()
+        )
+
+        event = OrderFillEvent(
+            job_id=job_id,
+            node_id=node_id,
+            order_no=fill.order_no,
+            order_date=fill.order_date,
+            execution_id=fill.execution_id,
+            symbol=fill.symbol,
+            exchange=fill.exchange,
+            side=fill.side,
+            quantity=fill.quantity,
+            price=fill.price,
+            fill_time=fill.fill_time,
+            product=tracker.product,
+            provider=tracker.provider,
+            classification=classification,
+            commda_code=fill.commda_code,
+            trading_mode=tracker.trading_mode,
+            received_at=received_iso,
+        )
+        await self.notify_order_fill(event)
+
+    async def notify_order_fill(self, event: OrderFillEvent) -> None:
+        """Notify all listeners about a confirmed order fill (facts only)."""
+        if not self._listeners:
+            return
+
+        for listener in self._listeners:
+            try:
+                await listener.on_order_fill(event)
+            except Exception as e:
+                logger.warning(f"Listener error on_order_fill: {e}")
+
+        # SSE 스트림 전송을 위해 이벤트 루프에 제어권 양보
+        await asyncio.sleep(0)
+
     async def cancel_workflow_order(
         self,
         order_no: str,

{programgarden-1.35.0 → programgarden-1.36.0}/programgarden/database/workflow_position_tracker.py

@@ -19,7 +19,7 @@ import re
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from decimal import Decimal, ROUND_HALF_UP
-from typing import Dict, List, Optional, Any, Tuple
+from typing import Dict, List, Optional, Any, Tuple, Callable, Awaitable
 from pathlib import Path
 
 logger = logging.getLogger(__name__)
@@ -184,8 +184,69 @@ class WorkflowPositionTracker:
         # 역산 불가한 틱에서는 이 캐시(최근 성공값)로 폴백해 FIFO 산술을 스케일한다.
         self._multiplier_cache: Dict[str, Decimal] = {}
 
+        # 체결 확정 콜백. 원장에 **새로** 기록된 체결마다 정확히 1회 발화한다 —
+        # 즉시/버퍼/타임아웃 경로가 모두 _process_fill_internal 을 거치므로 한 곳에서
+        # 부른다. 리플레이(동일 execution identity 재도착)는 그 앞에서 조기 반환하므로
+        # 재발화하지 않는다. 컨텍스트가 이걸 on_order_fill 리스너로 연결한다.
+        self._on_fill_classified: Optional[
+            Callable[["PendingFill", str], Awaitable[None]]
+        ] = None
+
         # DB 초기화
         self._init_db()
+
+    def set_fill_classified_callback(
+        self,
+        callback: Optional[Callable[["PendingFill", str], Awaitable[None]]],
+    ) -> None:
+        """Register an async callback fired once per newly recorded fill.
+
+        The callback receives ``(fill: PendingFill, classification: str)`` where
+        classification is one of "workflow" | "manual" | "unknown_api" | "other".
+        It must not mutate ledger state; exceptions raised by it are caught and
+        logged so they never break FIFO recording.
+        """
+        self._on_fill_classified = callback
+
+    def lookup_order_identity(
+        self,
+        order_no: str,
+        order_date: str,
+    ) -> Optional[Tuple[Optional[str], Optional[str]]]:
+        """Return ``(job_id, node_id)`` for a recorded workflow order, else None.
+
+        Scoped to this ledger's product/provider/trading mode and the order date.
+        Matches the exact order number first, then the normalized form (so
+        zero-padding differences between the order ACK and the fill still map).
+        A fill that is not one of our workflow orders returns None (node_id then
+        stays None on the emitted event).
+        """
+        try:
+            norm = self._normalize_identifier(order_no)
+        except ValueError:
+            norm = None
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                rows = conn.execute(
+                    """
+                    SELECT order_no, job_id, node_id FROM workflow_orders
+                    WHERE product = ? AND provider = ? AND trading_mode = ? AND order_date = ?
+                    """,
+                    (self.product, self.provider, self.trading_mode, order_date),
+                ).fetchall()
+        except Exception as e:
+            logger.warning(f"lookup_order_identity failed: {e}")
+            return None
+        for row_order_no, job_id, node_id in rows:
+            if row_order_no == order_no:
+                return (job_id, node_id)
+            if norm is not None:
+                try:
+                    if self._normalize_identifier(row_order_no) == norm:
+                        return (job_id, node_id)
+                except ValueError:
+                    continue
+        return None
     
     def _init_db(self) -> None:
         """데이터베이스 테이블 초기화"""
@@ -410,6 +471,7 @@ class WorkflowPositionTracker:
     
     async def _process_buffered_fill(self, order_no: str, order_date: str) -> None:
         """Process all buffered partial fills after recording their order."""
+        notifications: list = []
         async with self._buffer_lock:
             for key, fill in list(self._pending_fills.items()):
                 if fill.order_date != order_date:
@@ -418,8 +480,9 @@ class WorkflowPositionTracker:
                 if self._normalize_identifier(fill.execution_id) is not None:
                     matches = self._normalize_identifier(fill.order_no) == self._normalize_identifier(order_no)
                 if matches:
-                    await self._process_fill_internal(fill, "workflow")
+                    await self._process_fill_internal(fill, "workflow", notifications)
                     self._pending_fills.pop(key)
+        await self._emit_fill_notifications(notifications)
     
     async def record_fill(
         self,
@@ -480,6 +543,8 @@ class WorkflowPositionTracker:
             execution_id=execution_id, account_avg_price=account_avg_price,
         )
         identity = self._execution_key(fill)
+        notifications: list = []
+        result: Optional[str] = None
         async with self._buffer_lock:
             if identity is not None:
                 for pending in self._pending_fills.values():
@@ -498,31 +563,36 @@ class WorkflowPositionTracker:
             # of a hardcoded '40', our own OPEN-API fills may not carry '40'; the
             # old media-first ordering would then misfile them as manual.)
             if self._is_workflow_fill(fill):
-                return await self._process_fill_internal(fill, "workflow")
-            # No matching order. Classify by the published media table
-            # (MEDIA_CODES_* above) — never by "not 40":
-            #   human (85 HTS / 22 iPhone / 23 Android / 00 branch) → "manual"
-            #   other (96/LP/SK/SO or unlisted)                    → "other"
-            #   api (40/41/43) or blank                            → buffer below
-            channel = media_channel(commda_code)
-            if channel == "human":
-                return await self._process_fill_internal(fill, "manual")
-            if channel == "other":
-                # A code the table does not attribute — more of these exist than
-                # we have measured (only 40/51/85/03 are live-observed so far).
-                # Log it so the table can grow from evidence, never from guesses.
-                logger.info("Unlisted media code %r on fill %s/%s — classified other",
-                            commda_code, order_date, order_no)
-                return await self._process_fill_internal(fill, "other")
-
-            # An API code or an empty media code ("medium unknown"): buffer to
-            # give a lagging order record a chance to arrive, then
-            # _process_timeout_fill files it as workflow (matched) or unknown_api
-            # (unmatched). An unknown medium is never asserted to be a person's
-            # HTS trade, so it floors to unknown_api rather than manual.
-            self._next_pending_fill += 1
-            key = self._next_pending_fill
-            self._pending_fills[key] = fill
+                result = await self._process_fill_internal(fill, "workflow", notifications)
+            else:
+                # No matching order. Classify by the published media table
+                # (MEDIA_CODES_* above) — never by "not 40":
+                #   human (85 HTS / 22 iPhone / 23 Android / 00 branch) → "manual"
+                #   other (96/LP/SK/SO or unlisted)                    → "other"
+                #   api (40/41/43) or blank                            → buffer below
+                channel = media_channel(commda_code)
+                if channel == "human":
+                    result = await self._process_fill_internal(fill, "manual", notifications)
+                elif channel == "other":
+                    # A code the table does not attribute — more of these exist than
+                    # we have measured (only 40/51/85/03 are live-observed so far).
+                    # Log it so the table can grow from evidence, never from guesses.
+                    logger.info("Unlisted media code %r on fill %s/%s — classified other",
+                                commda_code, order_date, order_no)
+                    result = await self._process_fill_internal(fill, "other", notifications)
+                else:
+                    # An API code or an empty media code ("medium unknown"): buffer to
+                    # give a lagging order record a chance to arrive, then
+                    # _process_timeout_fill files it as workflow (matched) or unknown_api
+                    # (unmatched). An unknown medium is never asserted to be a person's
+                    # HTS trade, so it floors to unknown_api rather than manual.
+                    self._next_pending_fill += 1
+                    key = self._next_pending_fill
+                    self._pending_fills[key] = fill
+        # Emit any confirmed-fill notifications now that _buffer_lock is released.
+        if result is not None:
+            await self._emit_fill_notifications(notifications)
+            return result
         asyncio.create_task(self._process_timeout_fill(key))
         logger.debug(f"Buffered fill (waiting for order): {key}")
         return "pending"
@@ -530,14 +600,16 @@ class WorkflowPositionTracker:
     async def _process_timeout_fill(self, key: int) -> None:
         """Expire one arrival, without consuming a later partial's timeout."""
         await asyncio.sleep(self.FILL_BUFFER_TIMEOUT)
+        notifications: list = []
         async with self._buffer_lock:
             if key in self._pending_fills:
                 fill = self._pending_fills[key]
                 classification = "workflow" if self._is_workflow_fill(fill) else "unknown_api"
                 if classification == "unknown_api":
                     logger.warning("Fill expired before its order was recorded; classifying as unknown_api")
-                await self._process_fill_internal(fill, classification)
+                await self._process_fill_internal(fill, classification, notifications)
                 self._pending_fills.pop(key)
+        await self._emit_fill_notifications(notifications)
 
     @staticmethod
     def _normalize_identifier(value: Optional[str | int]) -> Optional[str]:
@@ -613,8 +685,18 @@ class WorkflowPositionTracker:
             """, identity[:4])
             return any(self._normalize_identifier(row[0]) == identity[4] for row in rows)
 
-    async def _process_fill_internal(self, fill: PendingFill, classification: str) -> str:
-        """Gate explicit replay before atomically mutating FIFO and history."""
+    async def _process_fill_internal(
+        self, fill: PendingFill, classification: str, notifications: list
+    ) -> str:
+        """Gate explicit replay before atomically mutating FIFO and history.
+
+        A newly confirmed fill is *queued* into ``notifications`` (a caller-owned
+        list) instead of being emitted here — the caller emits it via
+        ``_emit_fill_notifications`` AFTER releasing ``_buffer_lock``. Emitting
+        under the lock would await the listener chain (a network POST in the
+        pg-worker forwarder, ``request_timeout`` seconds) while holding
+        ``_buffer_lock``, serializing every other broker fill push behind it.
+        Replays return early and queue nothing (no re-fire)."""
         fill_datetime = f"{fill.order_date}_{fill.fill_time}"
 
         with sqlite3.connect(self.db_path) as conn:
@@ -681,8 +763,31 @@ class WorkflowPositionTracker:
         self.fill_revision += 1
 
         logger.debug(f"Processed fill: {fill.symbol} {fill.side} {fill.quantity}@{fill.price} [{classification}] ({self.trading_mode})")
+
+        # 새 체결이 원장에 확정됐다 → on_order_fill 통지를 큐잉한다(1회 발화).
+        # 실제 emit 은 caller 가 _buffer_lock 을 놓은 뒤 _emit_fill_notifications
+        # 로 수행한다(락 안에서 리스너 network POST 를 await 하지 않기 위함).
+        # 리플레이는 위에서 previous 반환으로 이미 걸러졌으므로 여기 오지 않는다.
+        if self._on_fill_classified is not None:
+            notifications.append((fill, classification))
+
         return classification
-    
+
+    async def _emit_fill_notifications(self, notifications: list) -> None:
+        """Emit queued on_order_fill notifications OUTSIDE ``_buffer_lock``.
+
+        Each caller collects confirmed fills into its own list under the lock
+        (via ``_process_fill_internal``) and drains them here once the lock is
+        released, so a slow listener never blocks other broker fill pushes.
+        """
+        if self._on_fill_classified is None:
+            return
+        for fill, classification in notifications:
+            try:
+                await self._on_fill_classified(fill, classification)
+            except Exception as cb_err:
+                logger.warning(f"Fill-classified callback error: {cb_err}")
+
     def _process_sell_fifo(
         self,
         cursor: sqlite3.Cursor,

{programgarden-1.35.0 → programgarden-1.36.0}/programgarden/executor.py

@@ -14484,7 +14484,7 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         order_type = config.get("order_type", "limit")
 
         # order 정규화
-        normalized_order = self._normalize_order(order, config)
+        normalized_order = self._normalize_order(order, config, context, node_id)
 
         if not normalized_order:
             context.log("warning", f"{node_type}: 주문할 종목이 없습니다", node_id)
@@ -14677,12 +14677,18 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         self,
         order_raw: Any,
         config: Dict[str, Any],
+        context: Optional["ExecutionContext"] = None,
+        node_id: Optional[str] = None,
     ) -> Optional[Dict[str, Any]]:
         """
         order 객체를 정규화 (단일 종목)
 
         입력: {symbol, exchange, quantity, price}
         출력: {symbol, exchange, quantity, price} (검증된 객체) 또는 None
+
+        symbol 또는 exchange 가 미해석 템플릿('{{ ... }}')이면 주문을 만들지 않고
+        None 을 반환한다 — 상류 바인딩이 풀리지 않은 것이므로, 이 값이 브로커
+        주문(매수·매도·시장가·지정가 전부)이나 원장에 절대 실려선 안 된다(C23).
         """
         if not order_raw:
             return None
@@ -14695,6 +14701,28 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             return None
 
         exchange = order_raw.get("exchange", "NASDAQ")
+
+        # C23: 미해석 템플릿 심볼/거래소 차단. 상류 노드가 실행되지 않았거나
+        # 포트가 없어 '{{ item.symbol }}' 같은 리터럴이 그대로 넘어온 경우다.
+        # 여기서 막지 않으면 매도 시장가·sizing price>0 분기에서 이 원문이 실제
+        # 브로커 주문(IsuNo)으로 나갈 수 있다.
+        if (isinstance(symbol, str) and "{{" in symbol) or (
+            isinstance(exchange, str) and "{{" in exchange
+        ):
+            if context is not None:
+                context.log(
+                    "error",
+                    f"주문 심볼/거래소가 미해석 템플릿입니다 — 주문을 만들지 않습니다 "
+                    f"(unresolved_template_symbol: symbol={symbol!r}, exchange={exchange!r})",
+                    node_id,
+                )
+            else:
+                logger.error(
+                    "_normalize_order: unresolved_template_symbol "
+                    "(symbol=%r, exchange=%r) — refusing to build order",
+                    symbol, exchange,
+                )
+            return None
         try:
             raw_quantity = float(order_raw.get("quantity", 0))
         except (ValueError, TypeError):
@@ -15838,6 +15866,31 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         은 ``order_result.diagnostics`` 로 추가 동봉한다. AI 챗봇 소비자는
         ``diagnostics`` 로 자가수정/안내를 결정적으로 분기할 수 있다.
         """
+        diagnostics = reject_info.model_dump() if reject_info else None
+
+        # C23 방어선: 미해석 템플릿이 결과의 symbol/exchange 자리를 차지하면 안 된다.
+        # _normalize_order 가 이미 그런 주문 자체를 만들지 않지만, 그래도 실패 결과를
+        # 남기는 경로(예: 현재가 조회 실패)가 템플릿 값으로 _order_result 를 부르면
+        # 여기서 symbol/exchange 를 None 으로 비우고, error 코드를 고정하며, 원문은
+        # diagnostics 에 보존한다 — 원장/서버가 심볼 자리에 '{{ ... }}' 를 절대 받지
+        # 않게(prod 실측 order_fills id=17 재발 차단).
+        if (isinstance(symbol, str) and "{{" in symbol) or (
+            isinstance(exchange, str) and "{{" in exchange
+        ):
+            template_diag = {
+                "unresolved_template": True,
+                "raw_symbol": symbol,
+                "raw_exchange": exchange,
+            }
+            diagnostics = (
+                {**diagnostics, **template_diag}
+                if isinstance(diagnostics, dict) else template_diag
+            )
+            error = "unresolved_template_symbol"
+            success = False
+            symbol = None
+            exchange = None
+
         return {
             "order_result": {
                 "success": success,
@@ -15848,7 +15901,7 @@ class NewOrderNodeExecutor(NodeExecutorBase):
                 "price": price,
                 "status": "submitted" if success else "failed",
                 "error": error,
-                "diagnostics": reject_info.model_dump() if reject_info else None,
+                "diagnostics": diagnostics,
             },
             "order_id": order_id,
         }

{programgarden-1.35.0 → programgarden-1.36.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.35.0"
+version = "1.36.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -29,11 +29,14 @@ lxml = "^6.0.2"
 pytickersymbols = {version = ">=1.17.5", python = ">=3.12,<4.0"}
 aiosqlite = "^0.20.0"
 litellm = ">=1.40.0"
-# 🔴 core 하한은 1.26.0 이어야 한다 — context.py 가 event_data 에 personal_metrics 를
-# 무조건 실어 WorkflowPnLEvent(**event_data) 를 만드는데, 그 필드는 core 1.26.0 에서
-# 추가됐다. 하한을 낮게 두면 core 1.25.x 로 해석된 환경에서 생성이 TypeError 로 죽고,
-# 그 예외가 바로 위 except Exception 에 삼켜져 **PnL 이벤트가 통째로 조용히 멈춘다.**
-programgarden-core = "^1.26.0"
+# 🔴 core 하한은 1.28.0 이어야 한다 — 이 엔진은 import 시점에 context.py 가
+# `from programgarden_core.bases.listener import OrderFillEvent` 를 eager import
+# 한다(C24). OrderFillEvent 는 core 1.28.0 에서 신설됐으므로, 하한을 낮게 두면
+# 구 core(≤1.27.0)로 resolve 된 환경에서 `import programgarden` 자체가 ImportError
+# 로 통째 실패한다(1.35.1 의 조용한 TypeError 보다 강한 모듈 로드 실패).
+# (1.26.0 이후로도 context.py 는 WorkflowPnLEvent(**event_data) 에 personal_metrics
+#  를 무조건 실으므로 그 하한 근거도 이 상한에 포함된다.)
+programgarden-core = "^1.28.0"
 programgarden-finance = "^1.9.5"
 programgarden-community = "^1.15.0"