programgarden 2.5.6__tar.gz → 2.6.1__tar.gz

{programgarden-2.5.6 → programgarden-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.5.6
+Version: 2.6.1
 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 (>=2.3.1,<3.0.0)
-Requires-Dist: programgarden-core (>=2.5.3,<3.0.0)
+Requires-Dist: programgarden-core (>=2.6.1,<3.0.0)
 Requires-Dist: programgarden-finance (>=2.0.1,<3.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
@@ -29,6 +29,19 @@ Description-Content-Type: text/markdown
 
 # ProgramGarden
 
+An unreleased [stock history interval correction](../../docs/stock-history-interval-contract.md)
+rejects unsupported intraday periods instead of silently querying daily bars.
+Supported g3204 periods retain their existing requests and output contract.
+
+An unreleased [futures detail and durable state candidate](../../docs/futures-contract-details-and-rollover-state.md)
+adds exact o3105 metadata, opt-in execution-scoped SQLite and XHKG calendar
+intersection. Missing evidence remains explicit; this does not authorize orders.
+
+An unreleased [offline temporal replay extension](../../docs/offline-temporal-replay.md)
+supports explicit bounded multi-day acceptance without changing the default
+32-event worker/save path. Public package release remains pending; the server
+team has validated a private DEV candidate with the same runtime changes.
+
 The REST overseas-stock account output preserves broker-reported `sellable_qty`
 separately from holdings; absent capacity remains null. See
 [the sell-capacity contract](../../docs/overseas-stock-sellable-quantity.md).

{programgarden-2.5.6 → programgarden-2.6.1}/README.md

@@ -1,5 +1,18 @@
 # ProgramGarden
 
+An unreleased [stock history interval correction](../../docs/stock-history-interval-contract.md)
+rejects unsupported intraday periods instead of silently querying daily bars.
+Supported g3204 periods retain their existing requests and output contract.
+
+An unreleased [futures detail and durable state candidate](../../docs/futures-contract-details-and-rollover-state.md)
+adds exact o3105 metadata, opt-in execution-scoped SQLite and XHKG calendar
+intersection. Missing evidence remains explicit; this does not authorize orders.
+
+An unreleased [offline temporal replay extension](../../docs/offline-temporal-replay.md)
+supports explicit bounded multi-day acceptance without changing the default
+32-event worker/save path. Public package release remains pending; the server
+team has validated a private DEV candidate with the same runtime changes.
+
 The REST overseas-stock account output preserves broker-reported `sellable_qty`
 separately from holdings; absent capacity remains null. See
 [the sell-capacity contract](../../docs/overseas-stock-sellable-quantity.md).

programgarden-2.6.1/programgarden/database/sqlite_scope.py

@@ -0,0 +1,19 @@
+"""Opt-in strategy SQLite namespace below the host-provided durable directory."""
+import hashlib
+import re
+
+
+def scoped_sqlite_filename(config, context):
+    name = config.get('db_name', 'default.db')
+    scope = config.get('storage_scope', 'shared')
+    if scope == 'shared':
+        return name
+    if scope != 'execution':
+        raise ValueError('Unknown SQLite storage scope')
+    if not isinstance(name, str) or not re.fullmatch(r'[A-Za-z0-9_-][A-Za-z0-9_.-]{0,119}\.db', name):
+        raise ValueError('Execution-scoped SQLite requires a plain .db filename')
+    key = context.execution_key or context.workflow_id
+    if not isinstance(key, str) or not key.strip():
+        raise ValueError('Execution-scoped SQLite requires a stable execution or workflow identity')
+    basis = ('execution:' if context.execution_key else 'workflow:') + key
+    return 'strategy_' + hashlib.sha256(basis.encode()).hexdigest() + '_' + name

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/executor.py

@@ -6312,6 +6312,49 @@ class AccountNodeExecutor(NodeExecutorBase):
         return result
 
 
+class FuturesContractInfoNodeExecutor(NodeExecutorBase):
+    """Read exact contract details independently of quote availability."""
+
+    async def execute(self, node_id, node_type, config, context, **kwargs):
+        from programgarden.futures_contract_info import (
+            FuturesContractEvidenceError, build_contract_info_request, read_contract_info,
+            synthetic_contract_info,
+        )
+        config = evaluate_all_bindings(config, context, node_id)
+        try:
+            request = build_contract_info_request(config)
+            if context.is_deep_validate:
+                from programgarden import deep_fixtures
+                return deep_fixtures.apply_override(
+                    synthetic_contract_info(config), context.get_deep_fixture(node_id, node_type),
+                )
+            connection = config.get("connection")
+            if not isinstance(connection, dict) or connection.get("product") != "overseas_futures" or not connection.get("credential_id"):
+                raise FuturesContractEvidenceError("A matching futures broker connection is required")
+            try:
+                credential = exact_futures_credential(connection, context)
+            except ValueError as exc:
+                raise FuturesContractEvidenceError(str(exc)) from exc
+            if not credential or not credential.get("appkey") or not credential.get("appsecret"):
+                raise FuturesContractEvidenceError("The selected futures credential is unavailable")
+            ls, success, _ = ensure_ls_login(
+                credential["appkey"], credential["appsecret"], connection.get("paper_trading", False),
+                context, node_id, product="overseas_futures", caller_name="FuturesContractInfoNode",
+            )
+            if not success:
+                raise FuturesContractEvidenceError("The selected futures broker login failed")
+            response = await asyncio.wait_for(
+                ls.overseas_futureoption().market().o3105(body=request).req_async(), timeout=20,
+            )
+            return read_contract_info(response, config)
+        except (FuturesContractEvidenceError, asyncio.TimeoutError) as exc:
+            reason = str(exc) or "Futures contract detail query timed out"
+        except Exception as exc:
+            reason = f"Futures contract detail query failed ({type(exc).__name__})"
+        context.log("warning", reason, node_id)
+        return {"value": None, "verified": False, "missing_fields": [], "error": reason}
+
+
 class FuturesOrderableQuantityNodeExecutor(NodeExecutorBase):
     """Read per-contract capacity; never place an order or replace failed evidence."""
 
@@ -8479,7 +8522,19 @@ class RealOrderEventNodeExecutor(NodeExecutorBase):
         """LS증권 실시간 주문 이벤트 구독"""
 
         # secrets에서 인증 정보 가져오기
-        credential = context.get_credential()
+        if product == "overseas_futures":
+            try:
+                credential = exact_futures_credential(config.get("connection") or {}, context)
+            except ValueError:
+                return {"error": "The selected futures credential is unavailable"}
+            connection = config.get("connection") or {}
+            owner = tuple(connection.get(key) for key in ("broker_node_id", "credential_id", "paper_trading"))
+            prior_owner = getattr(context, "_futures_order_event_owner", None)
+            if prior_owner is not None and prior_owner != owner:
+                return {"error": "A futures event stream cannot be shared across broker connections"}
+            context._futures_order_event_owner = owner
+        else:
+            credential = context.get_credential()
 
         if not credential:
             context.log("error", "Credential not found in secrets", node_id)
@@ -8487,7 +8542,8 @@ class RealOrderEventNodeExecutor(NodeExecutorBase):
 
         appkey = credential.get("appkey")
         appsecret = credential.get("appsecret")
-        paper_trading = credential.get("paper_trading", False)
+        paper_trading = (config.get("connection", {}).get("paper_trading", False)
+                         if product == "overseas_futures" else credential.get("paper_trading", False))
 
         if not appkey or not appsecret:
             context.log("error", "appkey/appsecret not found in credential", node_id)
@@ -12130,7 +12186,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
     HistoricalDataNode executor - 과거 OHLCV 데이터 조회
     
     LS Finance Chart API를 사용하여 과거 차트 데이터를 조회합니다.
-    - 해외주식: g3103 (일/주/월봉)
+    - Overseas stock: g3204 (daily/weekly/monthly/yearly; no intraday)
     - 해외선물: o3108 (일봉), o3103 (분봉)
     """
 
@@ -12152,6 +12208,15 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
     ) -> Dict[str, Any]:
         """과거 데이터 조회"""
 
+        # Reject unsupported stock periods before fixtures can manufacture success.
+        # The broker-specific fetch repeats this guard for direct/legacy callers.
+        connection = config.get("connection")
+        product = connection.get("product") if isinstance(connection, dict) else None
+        if node_type == "OverseasStockHistoricalDataNode" or (
+            node_type == "HistoricalDataNode" and product in (None, "overseas_stock")
+        ):
+            self._stock_history_gubun(config.get("interval", "1d"))
+
         # deep_validate: HistoricalDataNode hits the real LS API. Inject a fixture
         # time series so the flow completes without a network call.
         if context.is_deep_validate:
@@ -12395,6 +12460,18 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         # 파싱 실패 시 오늘 날짜 반환
         return datetime.now().strftime("%Y%m%d")
 
+    @staticmethod
+    def _stock_history_gubun(interval: str) -> str:
+        """Reject unsupported periods instead of relabeling daily bars."""
+        periods = {"1d": "2", "1w": "3", "1M": "4", "1Y": "5"}
+        if not isinstance(interval, str) or interval not in periods:
+            raise ValueError(
+                "UNSUPPORTED_STOCK_HISTORY_INTERVAL: OverseasStockHistoricalDataNode "
+                "supports 1d, 1w, 1M and 1Y through LS g3204. "
+                "Intraday g3203 is not supported; select a supported period explicitly."
+            )
+        return periods[interval]
+
     async def _fetch_overseas_stock(
         self,
         symbols: List[str],
@@ -12416,6 +12493,9 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
         반환: [{symbol, exchange, time_series: [{date, open, high, low, close, volume}, ...]}, ...]
         """
         
+        # Validate before credential access or login, outside the soft-failure handler.
+        gubun = self._stock_history_gubun(interval)
+
         credential = context.get_credential()
         if not credential:
             context.log("error", "Credential not set for HistoricalDataNode", node_id)
@@ -12438,10 +12518,6 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             
             api = ls.overseas_stock()
 
-            # interval → gubun 변환 (g3204: 2=일, 3=주, 4=월, 5=년)
-            gubun_map = {"1d": "2", "1w": "3", "1M": "4", "1Y": "5"}
-            gubun = gubun_map.get(interval, "2")
-
             # 거래소 코드 매핑 (역변환용)
             exchcd_to_exchange = {"82": "NASDAQ", "81": "NYSE", "83": "AMEX"}
 
@@ -19886,7 +19962,8 @@ class SQLiteNodeExecutor(NodeExecutorBase):
         import os
         from programgarden.database.query_builder import SQLQueryBuilder
         
-        db_name = config.get("db_name", "default.db")
+        from programgarden.database.sqlite_scope import scoped_sqlite_filename
+        db_name = scoped_sqlite_filename(config, context)
         operation = config.get("operation", "simple")
 
         # dry_run 모드에서는 SELECT만 허용. INSERT/UPDATE/DELETE/UPSERT는
@@ -20334,6 +20411,7 @@ class WorkflowExecutor:
             "OverseasStockSymbolQueryNode": SymbolQueryNodeExecutor(),
             "OverseasFuturesSymbolQueryNode": SymbolQueryNodeExecutor(),
             "FuturesContractNode": FuturesContractNodeExecutor(),
+            "OverseasFuturesContractInfoNode": FuturesContractInfoNodeExecutor(),
             "SymbolFilterNode": SymbolFilterNodeExecutor(),
             "ExclusionListNode": ExclusionListNodeExecutor(),
             "MarketUniverseNode": MarketUniverseNodeExecutor(),
@@ -22055,6 +22133,7 @@ class WorkflowJob:
         # 종목 마스터 조회 노드 — 배열을 **생성**하는 쪽이다. 상류에 배열이 붙었다고
         # 아이템 수만큼 마스터 조회를 반복하면 같은 전체 목록을 N 번 받아온다.
         "FuturesContractNode",
+        "OverseasFuturesContractInfoNode",  # One exact identity; explicit SplitNode for a batch.
         "OverseasFuturesSymbolQueryNode", "OverseasStockSymbolQueryNode", "KoreaStockSymbolQueryNode",
         "SymbolFilterNode",  # 집합 연산 노드 (배열 입력/출력)
         # LogicNode 도 집합 연산 노드다 — 상류 조건 결과 **배열 전체**를 AND/OR 해야 한다.

programgarden-2.6.1/programgarden/futures_contract_info.py

@@ -0,0 +1,91 @@
+"""Strict o3105 detail projection shared by live nodes and offline replay.
+
+Request fields follow finance/example/overseas_futureoption/run_o3105.py.
+No current quote is needed to read valid static contract metadata.
+"""
+from datetime import UTC, datetime
+import math
+
+from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105InBlock
+
+
+TEXT_FIELDS = {
+    "symbol_name": "SymbolNm", "underlying_code": "BscGdsCd", "currency": "CrncyCd",
+    "trade_status_code": "DlPsblCd",
+}
+DATE_FIELDS = {
+    "maturity_date": "MtrtDt", "last_trading_date": "FnlDlDt", "first_notice_date": "FstTrsfrDt",
+    "master_received_date": "ApplDate", "korea_start_date": "DlDt",
+    "local_start_date": "OvsStrDay", "local_end_date": "OvsEndDay",
+}
+TIME_FIELDS = {"korea_start_time": "DlStrtTm", "korea_end_time": "DlEndTm",
+               "local_start_time": "OvsStrTm", "local_end_time": "OvsEndTm"}
+NUMBER_FIELDS = {"initial_margin": "OpngMgn", "maintenance_margin": "MntncMgn",
+                 "tick_size": "UntPrc", "tick_value": "MnChgAmt"}
+
+
+class FuturesContractEvidenceError(ValueError):
+    """Safe-to-display contract evidence error without broker payloads or secrets."""
+
+
+def build_contract_info_request(config):
+    identity = config.get("symbol")
+    if not isinstance(identity, dict) or not all(
+        isinstance(identity.get(key), str) and identity[key].strip() for key in ("symbol", "exchange")
+    ):
+        raise FuturesContractEvidenceError("An exact futures contract symbol and exchange are required")
+    return O3105InBlock(symbol=identity["symbol"].strip())
+
+
+def _text(block, field):
+    value = getattr(block, field) if field in block.model_fields_set else None
+    return value.strip() or None if isinstance(value, str) else None
+
+
+def _date_or_time(block, field, *, date):
+    value = _text(block, field)
+    if not value or len(value) != (8 if date else 6) or not value.isascii() or not value.isdigit():
+        return None
+    try:
+        parsed = datetime.strptime(value, "%Y%m%d" if date else "%H%M%S")
+    except ValueError:
+        return None
+    return parsed.date().isoformat() if date else parsed.time().isoformat()
+
+
+def read_contract_info(response, config, *, observed_at=None):
+    request = build_contract_info_request(config)
+    if response.status_code != 200 or response.error_msg or response.rsp_cd != "00000" or response.block is None:
+        raise FuturesContractEvidenceError("o3105 did not return a successful contract detail response")
+    block = response.block
+    if not {"Symbol", "ExchCd"} <= block.model_fields_set or block.Symbol.strip() != request.symbol:
+        raise FuturesContractEvidenceError("o3105 contract identity is absent or mismatched")
+    exchange = block.ExchCd.strip()
+    if exchange != config["symbol"]["exchange"].strip():
+        raise FuturesContractEvidenceError("o3105 exchange identity is absent or mismatched")
+    now = observed_at or datetime.now(UTC)
+    if now.tzinfo is None:
+        raise FuturesContractEvidenceError("Contract observation requires a timezone-aware timestamp")
+    value = {"symbol": block.Symbol.strip(), "exchange": exchange,
+             "source_tr": "o3105", "observed_at": now.astimezone(UTC).isoformat()}
+    value.update({name: _text(block, field) for name, field in TEXT_FIELDS.items()})
+    for fields, is_date in ((DATE_FIELDS, True), (TIME_FIELDS, False)):
+        value.update({name: _date_or_time(block, field, date=is_date) for name, field in fields.items()})
+    for name, field in NUMBER_FIELDS.items():
+        observed = getattr(block, field) if field in block.model_fields_set else None
+        valid = type(observed) in (int, float) and math.isfinite(observed) and observed >= 0
+        if name in ("tick_size", "tick_value"):
+            valid = valid and observed > 0
+        value[name] = float(observed) if valid else None
+    return {"value": value, "verified": True, "missing_fields": sorted(k for k, v in value.items() if v is None), "error": None}
+
+
+def synthetic_contract_info(config, *, observed_at=None):
+    """Legacy deep-check shape only; replay instead requires raw recorded evidence."""
+    from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105OutBlock, O3105Response
+    request = build_contract_info_request(config)
+    response = O3105Response(status_code=200, rsp_cd="00000", rsp_msg="Synthetic deep-check identity", block=O3105OutBlock(
+        Symbol=request.symbol, ExchCd=config["symbol"]["exchange"].strip(),
+    ))
+    # Unknown dates/margins intentionally stay unknown; do not manufacture rollover permission.
+    return read_contract_info(response, config, observed_at=observed_at)

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/replay_events.py

@@ -12,9 +12,20 @@ from programgarden.context import WorkflowEvent
 from programgarden.replay_contracts import ContractViolation, check_contract
 
 
-def checked_events(fixture):
+DEFAULT_EVENT_LIMIT = 32
+MAX_OFFLINE_EVENT_LIMIT = 4096
+
+
+def checked_events(fixture, *, event_limit=DEFAULT_EVENT_LIMIT):
+    """Allow a trusted offline caller to raise the bound, never a fixture field.
+
+    Interactive worker callers retain 32 events. Longer acceptance runs keep all
+    cron instants and one disposable state store, bounded by replay's timeout.
+    """
+    if type(event_limit) is not int or not 0 <= event_limit <= MAX_OFFLINE_EVENT_LIMIT:
+        raise ContractViolation("events", "Event limit must be an integer from 0 to 4096")
     events = fixture.get("events", [])
-    check_contract(events, {"type": "array", "maxItems": 32, "items": {
+    check_contract(events, {"type": "array", "maxItems": event_limit, "items": {
         "type": "object", "required": ["as_of", "type", "source_node_id"],
         "additionalProperties": False, "properties": {
             "as_of": {"type": "string", "format": "date-time"},
@@ -79,8 +90,8 @@ def event_fixture(fixture, event):
     return frame
 
 
-async def replay_events(job, runner, fixture, outcome):
-    events = checked_events(fixture)
+async def replay_events(job, runner, fixture, outcome, *, event_limit=DEFAULT_EVENT_LIMIT):
+    events = checked_events(fixture, event_limit=event_limit)
     # Ancestor-only node checks may not yet contain a later event source. Final
     # verification checks all declared events against the complete graph.
     pending = iter((index, event) for index, event in enumerate(events)

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/replay_scenarios.py

@@ -23,7 +23,7 @@ def check_financial_expectations(simulation, schema):
         raise ContractViolation("live_order_count", "Replay must never submit live orders")
 
 
-def check_final_expectations(result, fixture, graph):
+def check_final_expectations(result, fixture, graph, *, event_limit=32):
     """Final acceptance asserts outputs and financial state, not just no error."""
     expected = fixture.get("expected")
     if not isinstance(expected,dict) or not expected:
@@ -39,7 +39,7 @@ def check_final_expectations(result, fixture, graph):
         if node_id not in result.initial_executed:
             raise ContractViolation(node_id, "Required path was not reached")
     from programgarden.replay_events import checked_events
-    events = checked_events(fixture)
+    events = checked_events(fixture, event_limit=event_limit)
     if len(events) != len(result.events):
         raise ContractViolation("events", "Every declared final replay event must be observed")
     has_orders = any(node["type"] in ORDER_NODES for node in graph["nodes"])

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/replay_sources.py

@@ -10,7 +10,7 @@ from programgarden.replay_external import external_record
 from programgarden.replay_triggers import fixture_instant
 
 SOURCE_NODES = frozenset({"MarketUniverseNode",
-    "FuturesContractNode", "ScreenerNode", "OverseasFuturesOrderableQuantityNode"})
+    "FuturesContractNode", "ScreenerNode", "OverseasFuturesOrderableQuantityNode", "OverseasFuturesContractInfoNode"})
 
 
 def source_contract_catalog():
@@ -21,6 +21,7 @@ def source_contract_catalog():
     The parser and independently written assertions remain authoritative.
     """
     from programgarden_finance.ls.overseas_futureoption.market.o3101.blocks import O3101OutBlock
+    from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105Response
     from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01400.blocks import CIDBQ01400Response
     from programgarden_finance.ls.overseas_stock.market.g3101.blocks import G3101OutBlock
     from programgarden.executor import MarketUniverseNodeExecutor
@@ -39,6 +40,11 @@ def source_contract_catalog():
             "required_row_fields": ["Symbol", "BscGdsCd", "ExchCd", "LstngYr", "LstngM"],
             "notes": "Supply raw o3101 model fields, including explicit contract identity/month. "
                      "Native expiry/exchange/front-next selection runs at as_of; do not preselect results."},
+        "OverseasFuturesContractInfoNode": {"source_schema": O3105Response.model_json_schema(),
+            "notes": "Use the raw SDK o3105 response envelope, with status_code=200, rsp_cd=00000, "
+                     "no error_msg, and matching block.Symbol and block.ExchCd. Optional dates use "
+                     "YYYYMMDD, times HHMMSS. Omitted fields stay null; no quote is required. "
+                     "The recorded response is parsed by the native live detail parser."},
         "OverseasFuturesOrderableQuantityNode": {"source_schema": CIDBQ01400Response.model_json_schema(),
             "notes": "Use the SDK response envelope (block1, block2, status_code, rsp_cd, error_msg), "
                      "not LS wire block names. status_code=200, error_msg absent and rsp_cd=00000 or00136 "
@@ -104,6 +110,11 @@ async def execute_source(node, config, fixture, context):
         return FuturesContractNodeExecutor().select_recorded_master(rows,
             [p.strip().upper() for p in node.base_products], node.contract_selection, exchange,
             context, node.id, as_of=fixture_instant(context, node.id))
+    if node.type == "OverseasFuturesContractInfoNode":
+        from programgarden.futures_contract_info import read_contract_info
+        from programgarden_finance.ls.overseas_futureoption.market.o3105.blocks import O3105Response
+        response = O3105Response.model_validate(source, strict=True)
+        return read_contract_info(response, config, observed_at=fixture_instant(context, node.id))
     if node.type == "OverseasFuturesOrderableQuantityNode":
         from programgarden.futures_orderable import build_orderable_request, read_orderable_quantity
         from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ01400.blocks import CIDBQ01400Response

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/replay_sqlite.py

@@ -20,7 +20,8 @@ async def execute_sqlite(node_id, config, context):
     if not isinstance(name, str) or not re.fullmatch(r"[A-Za-z0-9_-][A-Za-z0-9_.-]{0,119}\.db", name):
         raise ContractViolation(node_id, "Replay SQLite requires a plain .db filename")
     root = Path(context._storage_dir).resolve()
-    path = root / name
+    from programgarden.database.sqlite_scope import scoped_sqlite_filename
+    path = root / scoped_sqlite_filename(config, context)
     if path.is_symlink() or path.resolve().parent != root:
         raise ContractViolation(node_id, "SQLite path leaves the replay workspace")
     operation = config.get("operation", "simple")

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/resolver.py

@@ -345,6 +345,7 @@ class WorkflowResolver:
 
         # Order routing choices are literals, never prices or item bindings.
         self._validate_order_enums(workflow, registry, result)
+        self._validate_stock_history_interval(workflow, registry, result)
 
         # 11. Static recommendations (topology analysis)
         for rec in run_static_recommendation_rules(
@@ -362,6 +363,29 @@ class WorkflowResolver:
 
         return result
 
+    def _validate_stock_history_interval(self, workflow, registry, result) -> None:
+        """Keep static/deep validation aligned with the stock chart executor."""
+        node_type = "OverseasStockHistoricalDataNode"
+        node_class = registry.get(node_type)
+        if node_class is None:
+            return
+        field = node_class.get_field_schema()["interval"]
+        for node in workflow.nodes:
+            if node.get("type") != node_type:
+                continue
+            if node.get("interval", field.default) in field.enum_values:
+                continue
+            result.add(build_error(
+                ErrorCode.INVALID_FIELD_ENUM,
+                "Stock historical intervals require a supported LS g3204 period; "
+                "intraday g3203 is not supported.",
+                location=ErrorLocation(
+                    node_id=node.get("id"), node_type=node_type, field_path="interval",
+                ),
+                available_values=field.enum_values,
+                suggestion="Choose 1d, 1w, 1M or 1Y explicitly; do not substitute daily bars for an intraday strategy.",
+            ))
+
     def _validate_order_enums(self, workflow, registry, result) -> None:
         """Enforce fixed price/order types without changing dynamic close sides."""
         from programgarden_core.models.field_binding import ExpressionMode

{programgarden-2.5.6 → programgarden-2.6.1}/programgarden/validation_replay.py

@@ -349,7 +349,8 @@ class ReplayExecutor(WorkflowExecutor):
 
 
 async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
-                 timeout: float = 30, node_under_test: str | None = None) -> ReplayResult:
+                 timeout: float = 30, node_under_test: str | None = None,
+                 event_limit: int = 32) -> ReplayResult:
     """Run actual scheduler/mappings in disposable state; no silent soft PASS.
 
     A node check executes its actual upstream setup in the same disposable
@@ -358,6 +359,9 @@ async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
     node_under_test and always start with another fresh workspace.
     An empty branch is not an exception; required activation/output expectations
     belong to the suite and are checked explicitly by the coordinator.
+    Offline acceptance may explicitly raise event_limit (at most 4096). The
+    default worker/save path stays at 32. Every scheduled instant is still
+    required; state and the timeout span the whole timeline without resets.
     """
     outcome = ReplayResult(False, content_hash(definition), content_hash(fixture))
     outcome.node_under_test = node_under_test
@@ -391,6 +395,9 @@ async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
         context.set_workflow_job(job)
         context.start()
         async def run_all():
+            # Reject an oversized/malformed timeline before any initial action.
+            from programgarden.replay_events import checked_events
+            checked_events(fixture, event_limit=event_limit)
             if any(node.node_type in ORDER_NODES for node in resolved.nodes.values()):
                 # A no-signal branch still has account state to verify. Starting
                 # the book only on the first order loses unchanged cash/holdings
@@ -407,7 +414,7 @@ async def replay(definition: dict[str, Any], fixture: dict[str, Any], *,
                                         for node in resolved.nodes}
                 outcome.main_executed = list(outcome.executed)
                 from programgarden.replay_events import replay_events
-                await replay_events(job, runner, fixture, outcome)
+                await replay_events(job, runner, fixture, outcome, event_limit=event_limit)
 
         try:
             await asyncio.wait_for(run_all(), timeout=timeout)

{programgarden-2.5.6 → programgarden-2.6.1}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "2.5.6"
+version = "2.6.1"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -36,7 +36,7 @@ litellm = ">=1.40.0"
 # 로 통째 실패한다(1.35.1 의 조용한 TypeError 보다 강한 모듈 로드 실패).
 # (1.26.0 이후로도 context.py 는 WorkflowPnLEvent(**event_data) 에 personal_metrics
 #  를 무조건 실으므로 그 하한 근거도 이 상한에 포함된다.)
-programgarden-core = "^2.5.3"
+programgarden-core = "^2.6.1"
 programgarden-finance = "^2.0.1"
 programgarden-community = "^2.3.1"