programgarden 2.7.1__tar.gz → 2.7.3__tar.gz

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

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

{programgarden-2.7.1 → programgarden-2.7.3}/programgarden/context.py

@@ -209,6 +209,8 @@ class ExecutionContext:
         )
         self._startup_reconciled = False
         self._startup_broker_snapshot = None
+        # Paper futures "no business date" waiting notice (informational only).
+        self._business_day_notice = None
         self.position_adjustments: List[Dict[str, Any]] = []
         self.context_params = context_params or {}
 
@@ -1886,6 +1888,13 @@ class ExecutionContext:
             except Exception as e:
                 logger.warning(f"Listener error on_risk_event: {e}")
 
+        # Informational broker facts (the paper futures waiting notice) are not
+        # risk alerts: screens get them through on_risk_event above, but they
+        # never become a RISK_ALERT notification (telegram/kakao/AI consumers).
+        from programgarden.paper_futures_business_date import INFORMATIONAL_BROKER_EVENT_TYPES
+        if event.event_type in INFORMATIONAL_BROKER_EVENT_TYPES:
+            return
+
         # RISK_ALERT 자동 래핑: risk_event → notification
         try:
             risk_sev = NotificationSeverity.CRITICAL if event.severity == "critical" else (

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

@@ -1,9 +1,10 @@
 """Read scoped startup evidence using existing SDK example query parameters."""
 
 import asyncio
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
+from typing import Any, Optional
 
 from .broker_evidence import checked_body, StartupQueryDateMismatch
 from .position_reconciliation import (
@@ -15,6 +16,10 @@ from .position_reconciliation import (
 class BrokerStartupSnapshot:
     positions: VerifiedPositionSnapshot
     pending_orders: tuple[dict, ...]
+    # Paper overseas futures only: the validated CIDBQ01500 observation
+    # (PaperFuturesBusinessDate; ``day`` is "" when the server gave no business
+    # date). None for live accounts and other products.
+    paper_business_date: Optional[Any] = field(default=None, repr=False, compare=False)
 
 
 def required(row, field):
@@ -57,6 +62,7 @@ async def read_broker_snapshot(ls, *, execution_key, product, provider, trading_
     observed_at = datetime.now(timezone.utc)
     day = observed_at.astimezone(timezone(timedelta(hours=9))).strftime("%Y%m%d")
     positions, pending = {}, []
+    paper_day = None
     if product == "korea_stock":
         from programgarden_finance.ls.korea_stock.extension.valuation import collect_domestic_trading_positions
         from programgarden_finance.ls.korea_stock.extension.account_queries import collect_domestic_open_orders
@@ -156,4 +162,5 @@ async def read_broker_snapshot(ls, *, execution_key, product, provider, trading_
         raise ReconciliationUnavailable("ambiguous_pending_orders")
     return BrokerStartupSnapshot(
         VerifiedPositionSnapshot(execution_key, product, provider, trading_mode, observed_at,
-                                 positions, source, True, True, tuple(pending)), tuple(pending))
+                                 positions, source, True, True, tuple(pending)), tuple(pending),
+        paper_business_date=paper_day)

{programgarden-2.7.1 → programgarden-2.7.3}/programgarden/database/position_reconciliation.py

@@ -81,6 +81,27 @@ def assert_order_evidence(conn, tracker, snapshot):
     whole quantity. Absence from a pending list does not prove cancellation.
     In particular a partially filled order must not disappear from this check
     merely because one trade_history row already exists.
+
+    Order-date matching mirrors the fill tracker. The tracker records a fill
+    under *its own* execution date and associates it with an order whose
+    recorded date differs by at most one day (``_order_date_window``): a
+    futures order placed on D fills on D+1 at the paper night session and the
+    07:00 KST business-day roll, and an overseas-stock order straddling KST
+    midnight fills on D-1. Matching the recorded fills to the order on the
+    exact ``order_date`` alone counted those real fills as missing, so a
+    futures run — which has no missing-fill recovery path — stayed held at the
+    broker node on every restart forever (``owned_fills_require_reconciliation``).
+
+    This now claims exact-date fills first across every order, then widens to
+    the same D-1/D+1 window. The window is a heuristic (the daily-reset order
+    number can be reissued on an adjacent day), so a windowed fill is counted
+    only when its symbol, side and workflow classification match the order and
+    it carries — or is a known legacy of — a stable execution identity; a
+    mismatch is skipped, not raised, because it is a different order that merely
+    reused the number. A consumed-id set spans the whole loop, so one fill is
+    evidence for at most one order even when adjacent-day orders share a number.
+    An exact-date fill keeps the strict identity guard it always had. Fill
+    storage is unchanged.
     """
     pending = {}
     for row in snapshot.pending_orders:
@@ -100,43 +121,83 @@ def assert_order_evidence(conn, tracker, snapshot):
         SELECT order_date, order_no, symbol, side, quantity FROM workflow_orders
         WHERE product=? AND provider=? AND trading_mode=?
     """, scope).fetchall()
+    from .order_recovery import recovery_for_order
+    from .order_cancellation import cancellation_quantity
+
+    entries = []
     for day, number, symbol, side, raw_qty in orders:
-        key = day, str(number).lstrip("0")
-        fills = conn.execute("""
+        norm_number = str(number).lstrip("0")
+        recovery = recovery_for_order(conn, tracker, day, norm_number)
+        entries.append({
+            "day": day,
+            "number": norm_number,
+            "symbol": normalized_symbol(symbol, tracker.product),
+            "side": side,
+            "raw_qty": raw_qty,
+            "recovery": recovery,
+            "legacy_ids": set(json.loads(recovery["legacy_fill_ids"])) if recovery else set(),
+            "total": Decimal(0),
+        })
+
+    def fills_on(dates, number):
+        placeholders = ",".join("?" for _ in dates)
+        return conn.execute(f"""
             SELECT symbol, side, quantity, classification, execution_id, id FROM trade_history
-            WHERE product=? AND provider=? AND trading_mode=? AND order_date=?
-              AND ltrim(order_no, '0')=?
-        """, (*scope, *key)).fetchall()
-        symbol = normalized_symbol(symbol, tracker.product)
-        total = Decimal(0)
-        from .order_recovery import recovery_for_order
-        recovery = recovery_for_order(conn, tracker, *key)
-        legacy_ids = set(json.loads(recovery["legacy_fill_ids"])) if recovery else set()
-        for fill_symbol, fill_side, fill_qty, classification, execution_id, fill_id in fills:
-            if (normalized_symbol(fill_symbol, tracker.product) != symbol or fill_side != side
-                    or classification != "workflow"):
+            WHERE product=? AND provider=? AND trading_mode=?
+              AND order_date IN ({placeholders}) AND ltrim(order_no, '0')=?
+        """, (*scope, *dates, number)).fetchall()
+
+    consumed: set = set()
+
+    # Pass 1 — exact order-date fills, strict identity (behaviour unchanged).
+    for e in entries:
+        for fill_symbol, fill_side, fill_qty, classification, execution_id, fill_id in \
+                fills_on([e["day"]], e["number"]):
+            if (normalized_symbol(fill_symbol, tracker.product) != e["symbol"]
+                    or fill_side != e["side"] or classification != "workflow"):
                 raise ReconciliationUnavailable("ambiguous_order_fill_identity")
-            if not execution_id and fill_id not in legacy_ids:
+            if not execution_id and fill_id not in e["legacy_ids"]:
                 raise ReconciliationUnavailable("historical_execution_identity_unavailable")
-            total += quantity(fill_qty)
-        remainder = Decimal(0)
+            e["total"] += quantity(fill_qty)
+            consumed.add(fill_id)
+
+    # Pass 2 — the D-1/D+1 window; additive, every per-fill guard a skip condition.
+    for e in entries:
+        window = tracker._order_date_window(e["day"])
+        if not window:
+            continue
+        for fill_symbol, fill_side, fill_qty, classification, execution_id, fill_id in \
+                fills_on(window, e["number"]):
+            if fill_id in consumed:
+                continue
+            if (normalized_symbol(fill_symbol, tracker.product) != e["symbol"]
+                    or fill_side != e["side"] or classification != "workflow"):
+                continue
+            if not execution_id and fill_id not in e["legacy_ids"]:
+                continue
+            e["total"] += quantity(fill_qty)
+            consumed.add(fill_id)
+
+    # Per-order terminal evidence: pending, recovery, cancellation, equality.
+    for e in entries:
+        key = e["day"], e["number"]
+        symbol, side, total = e["symbol"], e["side"], e["total"]
         if key in pending:
             row = pending[key]
             if normalized_symbol(row["symbol"], tracker.product) != symbol or row["side"] != side:
                 raise ReconciliationUnavailable("pending_order_identity_mismatch")
-            remainder = quantity(row["remaining_quantity"])
             # A still executable order could fill between the two REST reads.
             # Wait for terminal evidence before changing any owned lots.
-            if remainder:
+            if quantity(row["remaining_quantity"]):
                 raise ReconciliationUnavailable("owned_order_still_pending")
+        recovery = e["recovery"]
         if recovery:
             if (recovery["symbol"] != symbol or recovery["side"] != side
-                    or quantity(recovery["total_quantity"]) != quantity(raw_qty)):
+                    or quantity(recovery["total_quantity"]) != quantity(e["raw_qty"])):
                 raise ReconciliationUnavailable("conflicting_recovered_order")
             total += quantity(recovery["recovered_quantity"])
-        from .order_cancellation import cancellation_quantity
         total += cancellation_quantity(conn, tracker, *key, symbol, side)
-        if total != quantity(raw_qty):
+        if total != quantity(e["raw_qty"]):
             raise ReconciliationUnavailable("owned_fills_require_reconciliation")
 
 

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

@@ -4757,6 +4757,18 @@ class BrokerNodeExecutor(NodeExecutorBase):
                     context=context, node_id=node_id, product=product, provider=provider,
                     appkey=appkey, appsecret=appsecret, paper_trading=paper_trading,
                 )
+            else:
+                # A later cycle: re-check an active "no business date" notice
+                # (at most one read per RECHECK_AFTER_SEC; never fails the node).
+                # It runs in the broker task registry, so the cycle's order
+                # nodes never wait for it and every stop cancels it.
+                from programgarden.paper_futures_business_date import refresh_business_day_notice_in_background
+                try:
+                    refresh_business_day_notice_in_background(
+                        context, "broker_recheck",
+                        lambda coroutine: self._start_background_task(context, coroutine))
+                except Exception as e:
+                    logger.warning("Waiting notice refresh not scheduled: %s", type(e).__name__)
 
             # ========================================
             # 위험관리 추적기 초기화 (노드/플러그인 risk feature 수집)
@@ -4913,6 +4925,10 @@ class BrokerNodeExecutor(NodeExecutorBase):
                 details={"adjustments": adjustments, "source": snapshot.positions.source,
                          "reason": "broker_quantity_reduction", "is_trade": False},
             ))
+        if snapshot.paper_business_date is not None:
+            from programgarden.paper_futures_business_date import observe_business_day
+            await observe_business_day(context, snapshot.paper_business_date, source="startup_check",
+                                       ls=ls, broker_node_id=node_id)
 
     def _collect_risk_features(self, context: ExecutionContext) -> set:
         """워크플로우 내 노드/플러그인의 risk feature 요구사항 수집.
@@ -6802,7 +6818,8 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
         context.log("info", f"{node_type}: provider={provider}, product={product}", node_id)
 
         if provider == "ls-sec.co.kr":
-            return await self._execute_ls(node_id, node_type, product, context)
+            return await self._execute_ls(node_id, node_type, product, context,
+                                          broker_node_id=broker_connection.get("broker_node_id"))
         else:
             context.log("error", f"Unsupported provider: {provider}", node_id)
             return self._empty_result(f"Unsupported provider: {provider}")
@@ -6813,6 +6830,7 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
         node_type: str,
         product: str,
         context: ExecutionContext,
+        broker_node_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """LS증권 미체결 조회"""
         credential = context.get_credential()
@@ -6840,7 +6858,7 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
             if product == "overseas_stock":
                 return await self._ls_overseas_stock(ls, node_id, context)
             elif product in ("overseas_futures", "overseas_futureoption"):
-                return await self._ls_overseas_futures(ls, node_id, context)
+                return await self._ls_overseas_futures(ls, node_id, context, broker_node_id=broker_node_id)
             elif product == "korea_stock":
                 return await self._ls_korea_stock(ls, node_id, context)
             else:
@@ -7003,13 +7021,16 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
             "count": len(open_orders),
         }
 
-    async def _ls_overseas_futures(self, ls, node_id: str, context: ExecutionContext) -> Dict[str, Any]:
+    async def _ls_overseas_futures(self, ls, node_id: str, context: ExecutionContext,
+                                   broker_node_id: Optional[str] = None) -> Dict[str, Any]:
         """해외선물 미체결 조회 (CIDBQ02400)"""
         from datetime import datetime
         from zoneinfo import ZoneInfo
         from programgarden.futures_exchange import resolve_contract_exchanges
         from programgarden.futures_read_evidence import require_complete_rows, require_pending_identity
-        from programgarden.paper_futures_business_date import is_paper_client, read_current_business_date
+        from programgarden.paper_futures_business_date import (
+            is_paper_client, observe_business_day, read_current_business_date,
+        )
         from programgarden.database.broker_evidence import StartupEvidenceUnavailable
         from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ02400.blocks import CIDBQ02400InBlock1
 
@@ -7026,6 +7047,7 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
             ThdayTpCode="1", OrdStatCode="2", BnsTpCode="0", QryTpCode="2",
             OrdPtnCode="00", OvrsDrvtFnoTpCode="A",
         )
+        inquiry_error = None
         try:
             if paper_day:
                 paper_day.scope.check(ls)
@@ -7036,7 +7058,18 @@ class OpenOrdersNodeExecutor(NodeExecutorBase):
             for row in rows:
                 require_pending_identity(row)
         except (ValueError, StartupEvidenceUnavailable) as exc:
-            return self._empty_result(str(exc))
+            inquiry_error = str(exc)
+        except Exception:
+            await observe_business_day(context, paper_day, source="open_orders", ls=ls,
+                                       broker_node_id=broker_node_id)
+            raise
+        # The positions answer itself is the evidence; no extra call. Listeners
+        # hear it only once the order inquiry is over, so their delivery time
+        # never counts against the inquiry's 60 s observation window.
+        await observe_business_day(context, paper_day, source="open_orders", ls=ls,
+                                   broker_node_id=broker_node_id)
+        if inquiry_error is not None:
+            return self._empty_result(inquiry_error)
 
         open_orders = []
         for item in rows:
@@ -17361,33 +17394,43 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ02400.blocks import (
                 CIDBQ02400InBlock1,
             )
-            from programgarden.paper_futures_business_date import is_paper_client, read_current_business_date
+            from programgarden.paper_futures_business_date import (
+                is_paper_client, observe_business_day, read_current_business_date,
+            )
 
             # A paper server can reject the documented blank same-day dates.
             # Use its fresh account-scoped date, including overnight sessions;
             # never replace missing evidence with the machine's calendar date.
             paper_day = await read_current_business_date(ls) if is_paper_client(ls) else None
             query_day = paper_day.day if paper_day else ""
-            if paper_day:
-                paper_day.scope.check(ls)
-            query = ls.overseas_futureoption().accno().CIDBQ02400(
-                body=CIDBQ02400InBlock1(
-                    RecCnt=1,
-                    IsuCodeVal="",          # 전체 종목
-                    QrySrtDt=query_day,
-                    QryEndDt=query_day,
-                    ThdayTpCode="1",        # 1: 당일조회
-                    OrdStatCode="0",        # 0: 전체(체결+미체결) — 상태 판정에 필요
-                    BnsTpCode="0",          # 0: 전체
-                    QryTpCode="1",          # 1: 역순(방금 낸 주문이 앞쪽)
-                    OrdPtnCode="00",        # 00: 전체
-                    OvrsDrvtFnoTpCode="A",  # A: 전체(선물+옵션)
+            try:
+                if paper_day:
+                    paper_day.scope.check(ls)
+                query = ls.overseas_futureoption().accno().CIDBQ02400(
+                    body=CIDBQ02400InBlock1(
+                        RecCnt=1,
+                        IsuCodeVal="",          # 전체 종목
+                        QrySrtDt=query_day,
+                        QryEndDt=query_day,
+                        ThdayTpCode="1",        # 1: 당일조회
+                        OrdStatCode="0",        # 0: 전체(체결+미체결) — 상태 판정에 필요
+                        BnsTpCode="0",          # 0: 전체
+                        QryTpCode="1",          # 1: 역순(방금 낸 주문이 앞쪽)
+                        OrdPtnCode="00",        # 00: 전체
+                        OvrsDrvtFnoTpCode="A",  # A: 전체(선물+옵션)
+                    )
                 )
-            )
-            response = await query.req_async()
+                response = await query.req_async()
 
-            if paper_day:
-                await paper_day.check_orders(ls, response, query)
+                if paper_day:
+                    await paper_day.check_orders(ls, response, query)
+            except Exception:
+                await observe_business_day(context, paper_day, source="fill_observation", ls=ls)
+                raise
+            # The positions answer is the evidence (no extra call). Listeners
+            # hear it only once the order inquiry is over, so their delivery
+            # time never counts against the inquiry's 60 s observation window.
+            await observe_business_day(context, paper_day, source="fill_observation", ls=ls)
 
             if getattr(response, "error_msg", None):
                 context.log("debug", f"CIDBQ02400 fill query error: {response.error_msg}", node_id)
@@ -24482,6 +24525,21 @@ class WorkflowJob:
         rate_limit_state["executing_count"] = max(0, current_count - 1)
         self.context.set_node_state(node_id, rate_limit_state_key, rate_limit_state)
 
+    def _refresh_business_day_notice_in_background(self, source: str) -> None:
+        """Re-check an active paper futures waiting notice without delaying this event.
+
+        The read is owned by the broker task registry, so every termination
+        path cancels it. Nothing starts unless the notice is active and due.
+        """
+        from programgarden.paper_futures_business_date import refresh_business_day_notice_in_background
+
+        try:
+            refresh_business_day_notice_in_background(
+                self.context, source,
+                lambda coroutine: BrokerNodeExecutor()._start_background_task(self.context, coroutine))
+        except Exception as e:  # Never let the notice disturb realtime handling.
+            logger.warning("Waiting notice refresh not scheduled: %s", type(e).__name__)
+
     async def _handle_realtime_update(self, event: WorkflowEvent) -> None:
         """
         Handle realtime update event
@@ -24501,7 +24559,9 @@ class WorkflowJob:
         if not trigger_nodes:
             _safe_print(f"  ⚠️ 트리거할 노드 없음, 스킵")
             return
-        
+
+        self._refresh_business_day_notice_in_background("realtime_recheck")
+
         logger.debug(f"Realtime update from {event.source_node_id}, triggering: {trigger_nodes}")
         _safe_print(f"  → {event.source_node_id}에서 트리거: {trigger_nodes}")
         

programgarden-2.7.3/programgarden/paper_futures_business_date.py

@@ -0,0 +1,355 @@
+"""Use fresh account-scoped broker dates for paper futures order inquiries.
+
+The published same-day blank-date contract conflicts with an observed paper
+response. This adapter uses CIDBQ01500's explicit current-date echo, never a
+machine date, and does not cache it across calls or relax unavailable evidence.
+
+When the paper server returns no business date at all (observed on weekends,
+when its overseas futures day is closed), the order inquiry uses the published
+blank-date same-day form instead, with the same response checks. This is the
+form the server startup gate already uses for that answer, so a start the
+server admits is not refused here.
+
+That answer is not an error, but the run then waits for the market to open.
+``BusinessDayNotice`` tells the run's listeners so through an informational
+``RiskEvent`` (``broker_business_day_unavailable``), and clears it
+(``broker_business_day_available``) as soon as a later read carries a date.
+Its details never carry a date, an account or key material.
+"""
+import asyncio
+from dataclasses import dataclass, field
+from datetime import datetime
+import hashlib
+import logging
+import re
+import time
+
+from programgarden.database.broker_evidence import StartupEvidenceUnavailable, broker_message, checked_body
+
+logger = logging.getLogger(__name__)
+
+_RESPONSE_CODE_REASON = "CIDBQ02400: unverified_response_code="
+
+
+def broker_business_day(value):
+    """The broker's explicit YYYYMMDD business date, or "" when none was given.
+
+    A blank, missing, padded or impossible value is "no date". It is never
+    replaced by a local, previous or cached date.
+    """
+    if not isinstance(value, str) or not re.fullmatch(r"[0-9]{8}", value):
+        return ""
+    try:
+        datetime.strptime(value, "%Y%m%d")
+    except ValueError:
+        return ""
+    return value
+
+
+def blank_date_unverified(response):
+    """No business date, and the blank-date answer's code was not accepted."""
+    return (f"CIDBQ02400: blank_date_unverified rsp_cd={getattr(response, 'rsp_cd', None)} "
+            f"rsp_msg={broker_message(getattr(response, 'rsp_msg', None))}")
+
+
+def is_paper_client(ls):
+    return getattr(getattr(ls, "token_manager", None), "paper_trading", None) is True
+
+
+@dataclass(frozen=True)
+class PaperFuturesScope:
+    manager: object = field(repr=False)
+    key_digest: str = field(repr=False)
+    started: float
+
+    @classmethod
+    def capture(cls, ls):
+        manager = getattr(ls, "token_manager", None)
+        key = getattr(manager, "appkey", None)
+        if not is_paper_client(ls) or not isinstance(key, str) or not key:
+            raise StartupEvidenceUnavailable("paper_futures_business_date: unavailable_client_scope")
+        return cls(manager, hashlib.sha256(key.encode()).hexdigest(), time.monotonic())
+
+    def check(self, ls):
+        current = self.capture(ls)
+        if current.manager is not self.manager or current.key_digest != self.key_digest:
+            raise StartupEvidenceUnavailable("paper_futures_business_date: client_scope_changed")
+        age = time.monotonic() - self.started
+        if age < 0 or age > 60:
+            raise StartupEvidenceUnavailable("paper_futures_business_date: expired_observation")
+
+
+@dataclass(frozen=True)
+class PaperFuturesBusinessDate:
+    """One fresh CIDBQ01500 observation for the following CIDBQ02400 read.
+
+    ``day`` is the broker's explicit business date, or "" when the paper server
+    returned none; "" selects the published blank-date same-day query (both
+    dates blank). ``account`` is the positions echo; it is always present with
+    a date and may be "" only on a blank-date answer.
+    """
+    day: str
+    account: str = field(repr=False)
+    scope: PaperFuturesScope = field(repr=False)
+
+    @property
+    def blank_date(self):
+        return not self.day
+
+    async def check_orders(self, ls, response, query):
+        self.scope.check(ls)
+        try:
+            body = await checked_body(response, "CIDBQ02400", query, paper_trading=True)
+        except StartupEvidenceUnavailable as exc:
+            # Without a business date the published blank-date form is the only
+            # query left; name that case, with the broker's answer, when its
+            # response code is not accepted. Other failures keep their reasons.
+            if self.blank_date and str(exc).startswith(_RESPONSE_CODE_REASON):
+                raise StartupEvidenceUnavailable(blank_date_unverified(response)) from None
+            raise
+        echo = body["CIDBQ02400OutBlock1"]
+        request = next(iter(query.request_data.body.values()))
+        expected = request.model_dump(exclude={"RecCnt"})
+        # A dated observation always carries its account; a blank-date one binds
+        # the account only when LS echoed it (the credential scope check below
+        # still proves both reads used the same token, key and paper mode).
+        if (request.ThdayTpCode != "1" or request.QrySrtDt != self.day
+                or request.QryEndDt != self.day or not isinstance(echo, dict)
+                or (self.account and echo.get("AcntNo") != self.account)
+                or any(name not in echo or echo[name] != value for name, value in expected.items())):
+            raise StartupEvidenceUnavailable("CIDBQ02400: business_date_scope_mismatch")
+        self.scope.check(ls)
+        return response.block2
+
+
+async def from_current_positions(ls, response, query, scope):
+    """Validate a just-fetched positions response without making another call."""
+    scope.check(ls)
+    body = await checked_body(response, "CIDBQ01500", query, paper_trading=True)
+    echo = body["CIDBQ01500OutBlock1"]
+    request = next(iter(query.request_data.body.values()))
+    expected = {"AcntTpCode": "1", "QryDt": "", "BalTpCode": "2", "FcmAcntNo": ""}
+    if any(getattr(request, name) != value for name, value in expected.items()):
+        raise StartupEvidenceUnavailable("CIDBQ01500: current_date_query_required")
+    if not isinstance(echo, dict) or any(echo.get(name) != value for name, value in expected.items() if name != "QryDt"):
+        raise StartupEvidenceUnavailable("CIDBQ01500: business_date_scope_mismatch")
+    day, account = broker_business_day(echo.get("QryDt")), echo.get("AcntNo")
+    if not isinstance(account, str) or not account.strip():
+        if day:
+            raise StartupEvidenceUnavailable("CIDBQ01500: unavailable_account_echo")
+        account = ""
+    if not day:
+        # Weekend paper answers carry no business date. The server startup gate
+        # uses the blank-date order form for this answer; so does the engine.
+        logger.info("CIDBQ01500: paper server returned no business date; "
+                    "using the published blank-date CIDBQ02400 same-day form")
+    scope.check(ls)
+    return PaperFuturesBusinessDate(day, account, scope)
+
+
+async def read_current_business_date(ls):
+    """One bounded read; the SDK retains its existing shared-key rate limiter."""
+    from programgarden_finance import CIDBQ01500
+
+    scope = PaperFuturesScope.capture(ls)
+    query = ls.overseas_futureoption().accno().CIDBQ01500(body=CIDBQ01500.CIDBQ01500InBlock1(
+        RecCnt=1, AcntTpCode="1", FcmAcntNo="", QryDt="", BalTpCode="2"))
+    response = await query.req_async()
+    return await from_current_positions(ls, response, query, scope)
+
+
+# --- Waiting notice: the paper server gave no business date -------------------
+#
+# A blank CIDBQ01500 QryDt is not an error (see above), but the run then has no
+# broker business day: on a weekend or before the open nothing trades until the
+# market opens. Hosts forward RiskEvent to their screens unchanged, so the
+# notice uses that existing event with severity "info" and two event types.
+# It is never a failure, never halts or releases an order, and its details never
+# carry a date or time (not the missing business date, not a local or previous
+# one), an account echo or key material; hosts stamp their own receive time.
+
+BUSINESS_DAY_UNAVAILABLE = "broker_business_day_unavailable"
+BUSINESS_DAY_AVAILABLE = "broker_business_day_available"
+INFORMATIONAL_BROKER_EVENT_TYPES = frozenset({BUSINESS_DAY_UNAVAILABLE, BUSINESS_DAY_AVAILABLE})
+MARKET_OPEN_WAIT_NOTICE = "market_open_wait"
+# At most one extra CIDBQ01500 read per this many seconds while the notice is
+# active, and only when the run is doing work (a broker node cycle or a
+# realtime event). Nothing is read on a quiet weekend.
+RECHECK_AFTER_SEC = 300
+# A still-active notice is repeated at most this often, for screens that join
+# while the run waits. No broker read is made for a repeat.
+REPEAT_AFTER_SEC = 60
+RECHECK_TIMEOUT_SEC = 30
+
+
+class BusinessDayNotice:
+    """Per-run state of the waiting notice (one ExecutionContext).
+
+    Observations are applied in the order their reads started, so a slower
+    read that began before a newer answer cannot undo it. A re-check that is
+    refused or fails keeps the current state and sends nothing.
+    """
+
+    def __init__(self):
+        self.active = False
+        self.broker_node_id = None
+        self._ls = None
+        self._last_read = None
+        self._last_applied_read = None
+        self._last_sent = None
+        self._in_flight = False
+        self._background = None
+
+    def due(self, now=None):
+        """Active and no read has started for RECHECK_AFTER_SEC seconds."""
+        now = time.monotonic() if now is None else now
+        return (self.active and not self._in_flight and self._ls is not None
+                and (self._last_read is None or now - self._last_read >= RECHECK_AFTER_SEC))
+
+    def _repeat_due(self, now):
+        return self._last_sent is not None and now - self._last_sent >= REPEAT_AFTER_SEC
+
+    def needs_refresh(self, now=None):
+        """A re-check or a repeat is due (cheap; no broker call)."""
+        now = time.monotonic() if now is None else now
+        return self.active and not self._in_flight and (self.due(now) or self._repeat_due(now))
+
+    async def observe(self, context, paper_day, *, source, ls, broker_node_id=None):
+        """Apply one validated CIDBQ01500 observation (no extra call)."""
+        if paper_day is None:
+            return
+        started = paper_day.scope.started
+        if self._last_applied_read is not None and started < self._last_applied_read:
+            return
+        self._last_applied_read = started
+        self._last_read = started if self._last_read is None else max(self._last_read, started)
+        if broker_node_id and not self.broker_node_id:
+            self.broker_node_id = broker_node_id
+        if paper_day.day:
+            if self.active:
+                self.active, self._ls = False, None
+                logger.info("CIDBQ01500: paper server returned a business date again; waiting notice cleared")
+                await self._send(context, active=False, source=source)
+            return
+        self._ls = ls
+        if not self.active:
+            self.active = True
+            await self._send(context, active=True, source=source)
+        elif self._last_sent is None or self._repeat_due(time.monotonic()):
+            await self._send(context, active=True, source=source)
+
+    async def refresh(self, context, source):
+        """At a work moment: re-read when due, else repeat a still-active notice."""
+        if not self.active or self._in_flight:
+            return
+        now = time.monotonic()
+        if self.due(now):
+            await self.recheck(context, source)
+        elif self._repeat_due(now):
+            await self._send(context, active=True, source=source)
+
+    async def recheck(self, context, source):
+        """One bounded CIDBQ01500 read on the run's existing client."""
+        ls = self._ls
+        if not self.active or self._in_flight or ls is None or not is_paper_client(ls):
+            return
+        if not getattr(context, "is_running", True) or getattr(context, "is_shutdown", False):
+            return
+        self._in_flight = True
+        self._last_read = time.monotonic()
+        try:
+            paper_day = await asyncio.wait_for(read_current_business_date(ls), timeout=RECHECK_TIMEOUT_SEC)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            # Refused, partial or unreachable: keep the notice, try again later.
+            logger.info("CIDBQ01500 business-date re-check unavailable (%s); waiting notice kept",
+                        type(exc).__name__)
+            return
+        finally:
+            self._in_flight = False
+        await self.observe(context, paper_day, source=source, ls=ls)
+
+    async def _send(self, context, *, active, source):
+        from programgarden_core.bases.listener import RiskEvent
+
+        self._last_sent = time.monotonic()
+        notify = getattr(context, "notify_risk_event", None)
+        if notify is None:
+            return
+        try:
+            await notify(RiskEvent(
+                job_id=getattr(context, "job_id", None),
+                event_type=BUSINESS_DAY_UNAVAILABLE if active else BUSINESS_DAY_AVAILABLE,
+                severity="info",
+                action_hint="advisory",
+                details={
+                    "notice": MARKET_OPEN_WAIT_NOTICE,
+                    "active": active,
+                    "broker_node_id": self.broker_node_id,
+                    "product": "overseas_futures",
+                    "trading_mode": "paper",
+                    "source": source,
+                    "evidence": "CIDBQ01500.QryDt",
+                    "recheck_after_sec": RECHECK_AFTER_SEC,
+                    "is_error": False,
+                    "is_trade": False,
+                },
+            ))
+        except Exception as exc:  # A listener problem never fails the run.
+            logger.warning("Waiting notice delivery failed: %s", type(exc).__name__)
+
+
+def business_day_notice(context):
+    """This run's notice, or None where none may be sent.
+
+    dry_run, deep_validate and replay validation (a dry_run) never send it, and
+    an object that is not an execution context (a bare test double) has none.
+    """
+    if getattr(context, "is_dry_run", False) or not hasattr(context, "_business_day_notice"):
+        return None
+    notice = context._business_day_notice
+    if notice is None:
+        notice = context._business_day_notice = BusinessDayNotice()
+    return notice
+
+
+async def observe_business_day(context, paper_day, *, source, ls, broker_node_id=None):
+    """Record a paper observation without ever failing the caller."""
+    notice = business_day_notice(context)
+    if notice is None or paper_day is None or not is_paper_client(ls):
+        return
+    try:
+        await notice.observe(context, paper_day, source=source, ls=ls, broker_node_id=broker_node_id)
+    except Exception as exc:
+        logger.warning("Waiting notice update failed: %s", type(exc).__name__)
+
+
+def refresh_business_day_notice_in_background(context, source, start_task):
+    """Schedule one refresh when due, through the caller's task registry.
+
+    For work moments that must not wait for a broker read (realtime updates
+    and later broker-node cycles).
+    ``start_task(coroutine)`` returns the task, or None when the run is
+    shutting down. At most one refresh is pending at a time.
+    """
+    notice = business_day_notice(context)
+    if notice is None or not notice.needs_refresh():
+        return None
+    if notice._background is not None and not notice._background.done():
+        return None
+    notice._background = start_task(refresh_business_day_notice(context, source))
+    return notice._background
+
+
+async def refresh_business_day_notice(context, source):
+    """Re-check an active notice at a work moment without ever failing the caller."""
+    notice = business_day_notice(context)
+    if notice is None or not notice.active:
+        return
+    try:
+        await notice.refresh(context, source)
+    except asyncio.CancelledError:
+        raise
+    except Exception as exc:
+        logger.warning("Waiting notice re-check failed: %s", type(exc).__name__)

{programgarden-2.7.1 → programgarden-2.7.3}/pyproject.toml

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

programgarden-2.7.1/programgarden/paper_futures_business_date.py

@@ -1,96 +0,0 @@
-"""Use fresh account-scoped broker dates for paper futures order inquiries.
-
-The published same-day blank-date contract conflicts with an observed paper
-response. This adapter uses CIDBQ01500's explicit current-date echo, never a
-machine date, and does not cache it across calls or relax unavailable evidence.
-"""
-from dataclasses import dataclass, field
-from datetime import datetime
-import hashlib
-import re
-import time
-
-from programgarden.database.broker_evidence import StartupEvidenceUnavailable, checked_body
-
-
-def is_paper_client(ls):
-    return getattr(getattr(ls, "token_manager", None), "paper_trading", None) is True
-
-
-@dataclass(frozen=True)
-class PaperFuturesScope:
-    manager: object = field(repr=False)
-    key_digest: str = field(repr=False)
-    started: float
-
-    @classmethod
-    def capture(cls, ls):
-        manager = getattr(ls, "token_manager", None)
-        key = getattr(manager, "appkey", None)
-        if not is_paper_client(ls) or not isinstance(key, str) or not key:
-            raise StartupEvidenceUnavailable("paper_futures_business_date: unavailable_client_scope")
-        return cls(manager, hashlib.sha256(key.encode()).hexdigest(), time.monotonic())
-
-    def check(self, ls):
-        current = self.capture(ls)
-        if current.manager is not self.manager or current.key_digest != self.key_digest:
-            raise StartupEvidenceUnavailable("paper_futures_business_date: client_scope_changed")
-        age = time.monotonic() - self.started
-        if age < 0 or age > 60:
-            raise StartupEvidenceUnavailable("paper_futures_business_date: expired_observation")
-
-
-@dataclass(frozen=True)
-class PaperFuturesBusinessDate:
-    day: str
-    account: str = field(repr=False)
-    scope: PaperFuturesScope = field(repr=False)
-
-    async def check_orders(self, ls, response, query):
-        self.scope.check(ls)
-        body = await checked_body(response, "CIDBQ02400", query, paper_trading=True)
-        echo = body["CIDBQ02400OutBlock1"]
-        request = next(iter(query.request_data.body.values()))
-        expected = request.model_dump(exclude={"RecCnt"})
-        if (request.ThdayTpCode != "1" or request.QrySrtDt != self.day
-                or request.QryEndDt != self.day or not isinstance(echo, dict)
-                or echo.get("AcntNo") != self.account
-                or any(name not in echo or echo[name] != value for name, value in expected.items())):
-            raise StartupEvidenceUnavailable("CIDBQ02400: business_date_scope_mismatch")
-        self.scope.check(ls)
-        return response.block2
-
-
-async def from_current_positions(ls, response, query, scope):
-    """Validate a just-fetched positions response without making another call."""
-    scope.check(ls)
-    body = await checked_body(response, "CIDBQ01500", query, paper_trading=True)
-    echo = body["CIDBQ01500OutBlock1"]
-    request = next(iter(query.request_data.body.values()))
-    expected = {"AcntTpCode": "1", "QryDt": "", "BalTpCode": "2", "FcmAcntNo": ""}
-    if any(getattr(request, name) != value for name, value in expected.items()):
-        raise StartupEvidenceUnavailable("CIDBQ01500: current_date_query_required")
-    if not isinstance(echo, dict) or any(echo.get(name) != value for name, value in expected.items() if name != "QryDt"):
-        raise StartupEvidenceUnavailable("CIDBQ01500: business_date_scope_mismatch")
-    day, account = echo.get("QryDt"), echo.get("AcntNo")
-    if not isinstance(day, str) or not re.fullmatch(r"[0-9]{8}", day):
-        raise StartupEvidenceUnavailable("CIDBQ01500: unavailable_business_date")
-    try:
-        datetime.strptime(day, "%Y%m%d")
-    except ValueError:
-        raise StartupEvidenceUnavailable("CIDBQ01500: invalid_business_date") from None
-    if not isinstance(account, str) or not account.strip():
-        raise StartupEvidenceUnavailable("CIDBQ01500: unavailable_account_echo")
-    scope.check(ls)
-    return PaperFuturesBusinessDate(day, account, scope)
-
-
-async def read_current_business_date(ls):
-    """One bounded read; the SDK retains its existing shared-key rate limiter."""
-    from programgarden_finance import CIDBQ01500
-
-    scope = PaperFuturesScope.capture(ls)
-    query = ls.overseas_futureoption().accno().CIDBQ01500(body=CIDBQ01500.CIDBQ01500InBlock1(
-        RecCnt=1, AcntTpCode="1", FcmAcntNo="", QryDt="", BalTpCode="2"))
-    response = await query.req_async()
-    return await from_current_positions(ls, response, query, scope)