programgarden 2.6.5__tar.gz → 2.6.7__tar.gz

{programgarden-2.6.5 → programgarden-2.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.6.5
+Version: 2.6.7
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -16,8 +16,8 @@ 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.6.2,<3.0.0)
-Requires-Dist: programgarden-finance (>=2.0.2,<3.0.0)
+Requires-Dist: programgarden-core (>=2.6.3,<3.0.0)
+Requires-Dist: programgarden-finance (>=2.0.5,<3.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
 Requires-Dist: pydantic (>=2.0.1,<3.0.0)
@@ -31,6 +31,20 @@ The 2.6.2 release candidate [futures minute alias correction](../../docs/futures
 
 # ProgramGarden
 
+The 2.6.7 release [futures TC2 confirmation handling](../../docs/release-2.6.7-validation.md)
+requires programgarden-finance 2.0.5, which reads overseas futures modify and
+cancel confirmations (TC2) as LS sends them and re-registers account events
+after a reconnect. The engine finds the workflow's order through
+`orgn_ordr_no`, uses the guide's side codes and skips frames the SDK could
+not read.
+
+The 2.6.6 release candidate [ranking nodes and runtime-values-as-data correction](../../docs/release-2.6.6-validation.md)
+adds KoreaStockRankingNode and OverseasStockRankingNode, evaluates only
+expression templates authored in the workflow, routes Gemini and DeepSeek
+credentials to their own APIs, and reads an unresolved futures position
+exchange again at most once per 5 minutes per contract instead of keeping it
+empty for the whole run.
+
 The 2.6.5 release candidate [futures position exchange correction](../../docs/futures-position-exchange.md)
 reads each futures position's and pending order's exchange from o3105 instead
 of a fixed `HKEX`; an unconfirmed exchange stays empty.
@@ -198,7 +212,11 @@ exchange execution numbers and broker execution numbers are not interchangeable.
 This ledger API alone does not reconcile finite workflows after their shutdown.
 
 Standalone futures TC3 callbacks interpret `s_b_ccd="1"` as sell and `"2"` as buy,
-matching the SDK contract. Unknown or blank side codes are logged and skipped
+matching the SDK contract. TC2 confirmations use the same codes and find the
+workflow's order through `orgn_ordr_no`: a futures modify or cancel gets its own
+new order number (LS paper, 2026-10-15), so the cancel confirmation cancels the
+original order in the ledger and a modify confirmation updates the successor row
+recorded by ModifyOrderNodeExecutor. Unknown or blank side codes are logged and skipped
 before any inventory write is scheduled. With an app order lifecycle handler,
 TC3 still bypasses this legacy fill path: canonical REST reconciliation remains
 the sole writer. This side correction does not establish an alias between TC3
@@ -307,7 +325,7 @@ job = await pg.run_async(
 
 ## 주요 특징
 
-- **노드 기반 DSL**: 72개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
+- **노드 기반 DSL**: 74개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
 - **실시간 처리**: WebSocket 기반 실시간 시세, 계좌, 체결 이벤트 수신
 - **AI Agent 통합**: LLMModelNode + AIAgentNode로 LLM 기반 분석/의사결정
 - **플러그인 확장**: 67개 내장 전략 플러그인 (RSI, MACD, 볼린저밴드, 이치모쿠, 듀얼모멘텀, 터틀브레이크아웃 등)
@@ -319,7 +337,7 @@ job = await pg.run_async(
 
 ```
 5-Layer Architecture:
-1. Registry Layer   - 노드/플러그인 메타데이터 (73개 노드, 77개 플러그인)
+1. Registry Layer   - 노드/플러그인 메타데이터 (76개 노드, 77개 플러그인)
 2. Credential Layer - 인증 정보 관리
 3. Definition Layer - JSON 워크플로우 정의 (노드, 엣지, 크레덴셜)
 4. Job Layer        - 상태 유지 실행 인스턴스 (최대 24시간 장기 실행)

{programgarden-2.6.5 → programgarden-2.6.7}/README.md

@@ -2,6 +2,20 @@ The 2.6.2 release candidate [futures minute alias correction](../../docs/futures
 
 # ProgramGarden
 
+The 2.6.7 release [futures TC2 confirmation handling](../../docs/release-2.6.7-validation.md)
+requires programgarden-finance 2.0.5, which reads overseas futures modify and
+cancel confirmations (TC2) as LS sends them and re-registers account events
+after a reconnect. The engine finds the workflow's order through
+`orgn_ordr_no`, uses the guide's side codes and skips frames the SDK could
+not read.
+
+The 2.6.6 release candidate [ranking nodes and runtime-values-as-data correction](../../docs/release-2.6.6-validation.md)
+adds KoreaStockRankingNode and OverseasStockRankingNode, evaluates only
+expression templates authored in the workflow, routes Gemini and DeepSeek
+credentials to their own APIs, and reads an unresolved futures position
+exchange again at most once per 5 minutes per contract instead of keeping it
+empty for the whole run.
+
 The 2.6.5 release candidate [futures position exchange correction](../../docs/futures-position-exchange.md)
 reads each futures position's and pending order's exchange from o3105 instead
 of a fixed `HKEX`; an unconfirmed exchange stays empty.
@@ -169,7 +183,11 @@ exchange execution numbers and broker execution numbers are not interchangeable.
 This ledger API alone does not reconcile finite workflows after their shutdown.
 
 Standalone futures TC3 callbacks interpret `s_b_ccd="1"` as sell and `"2"` as buy,
-matching the SDK contract. Unknown or blank side codes are logged and skipped
+matching the SDK contract. TC2 confirmations use the same codes and find the
+workflow's order through `orgn_ordr_no`: a futures modify or cancel gets its own
+new order number (LS paper, 2026-10-15), so the cancel confirmation cancels the
+original order in the ledger and a modify confirmation updates the successor row
+recorded by ModifyOrderNodeExecutor. Unknown or blank side codes are logged and skipped
 before any inventory write is scheduled. With an app order lifecycle handler,
 TC3 still bypasses this legacy fill path: canonical REST reconciliation remains
 the sole writer. This side correction does not establish an alias between TC3
@@ -278,7 +296,7 @@ job = await pg.run_async(
 
 ## 주요 특징
 
-- **노드 기반 DSL**: 72개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
+- **노드 기반 DSL**: 74개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
 - **실시간 처리**: WebSocket 기반 실시간 시세, 계좌, 체결 이벤트 수신
 - **AI Agent 통합**: LLMModelNode + AIAgentNode로 LLM 기반 분석/의사결정
 - **플러그인 확장**: 67개 내장 전략 플러그인 (RSI, MACD, 볼린저밴드, 이치모쿠, 듀얼모멘텀, 터틀브레이크아웃 등)
@@ -290,7 +308,7 @@ job = await pg.run_async(
 
 ```
 5-Layer Architecture:
-1. Registry Layer   - 노드/플러그인 메타데이터 (73개 노드, 77개 플러그인)
+1. Registry Layer   - 노드/플러그인 메타데이터 (76개 노드, 77개 플러그인)
 2. Credential Layer - 인증 정보 관리
 3. Definition Layer - JSON 워크플로우 정의 (노드, 엣지, 크레덴셜)
 4. Job Layer        - 상태 유지 실행 인스턴스 (최대 24시간 장기 실행)

programgarden-2.6.7/programgarden/binding_provenance.py

@@ -0,0 +1,181 @@
+"""Expressions run only from authored templates; runtime values are data.
+
+Before 2.6.6 a node's config was evaluated twice: the workflow job resolved
+``{{ … }}`` bindings (``WorkflowJob._resolve_config_expressions``) and the node
+executor then evaluated the already-resolved config again
+(``evaluate_all_bindings``). Any value produced at runtime that contained
+``{{`` — LLM text, HTTP bodies, broker strings, workflow inputs, credentials —
+was evaluated a second time in the workflow expression context.
+
+Invariant: an expression is evaluated only if its template text was authored
+in the workflow definition (the node config as stored in the DSL), and at most
+once per execution of that node (per iteration for deferred ``{{ item }}``
+bindings). The check is positional: a string at config path *P* is evaluated
+only while it is still exactly the authored string at *P*. Once a template has
+been resolved, the value at *P* is data and passes byte-identical.
+
+Each workflow job registers an authored snapshot per node
+(``ExecutionContext.register_authored_node_configs``). Without a snapshot (a
+node run outside a workflow job, e.g. ``NodeRunner``) the engine keeps the
+legacy behaviour and evaluates every template it is given, because that config
+is the caller's authored input.
+
+Source-code fields are never evaluated (``NEVER_EVALUATED_KEYS``).
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Any, Dict, Optional
+
+# A position the authored config does not have (engine-injected keys, runtime data).
+NOT_AUTHORED = object()
+# No authored snapshot for this node: evaluate every template (pre-2.6.6 behaviour).
+LEGACY = object()
+
+# Fields that hold source code, not templates. They are never evaluated, even
+# when the text contains ``{{ … }}``.
+NEVER_EVALUATED_KEYS: Dict[str, frozenset] = {
+    "CodeNode": frozenset({"code"}),
+}
+
+
+def authored_snapshot(node_type: str, config: Optional[Dict[str, Any]], fields: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """Deep copy of a node's authored config, as evaluation positions see it.
+
+    Plugin ``fields`` are exposed under the ``fields`` key (executors receive
+    them there). Never-evaluated keys are removed so their positions read as
+    not authored.
+    """
+    snapshot = copy.deepcopy(dict(config or {}))
+    if fields and "fields" not in snapshot:
+        snapshot["fields"] = copy.deepcopy(fields)
+    for key in NEVER_EVALUATED_KEYS.get(node_type, ()):
+        snapshot.pop(key, None)
+    return snapshot
+
+
+def authored_root(context: Any, node_id: Optional[str]) -> Any:
+    """The authored snapshot of ``node_id``, or ``LEGACY`` when none is registered."""
+    if node_id is None:
+        return LEGACY
+    getter = getattr(context, "authored_node_config", None)
+    if not callable(getter):
+        return LEGACY
+    try:
+        snapshot = getter(node_id)
+    except Exception:  # pragma: no cover - defensive (mock contexts)
+        return LEGACY
+    return snapshot if isinstance(snapshot, dict) else LEGACY
+
+
+def child(authored: Any, key: Any) -> Any:
+    """Authored value at ``key`` of a dict position."""
+    if authored is LEGACY:
+        return LEGACY
+    if isinstance(authored, dict):
+        return authored.get(key, NOT_AUTHORED)
+    return NOT_AUTHORED
+
+
+def element(authored: Any, index: int, length: int) -> Any:
+    """Authored value at ``index`` of a list position of ``length`` items."""
+    if authored is LEGACY:
+        return LEGACY
+    if isinstance(authored, list) and len(authored) == length:
+        return authored[index]
+    return NOT_AUTHORED
+
+
+def authored_at(context: Any, node_id: Optional[str], *path: Any) -> Any:
+    """Authored value at a top-level path of ``node_id`` (``LEGACY`` without a snapshot)."""
+    authored = authored_root(context, node_id)
+    for key in path:
+        authored = child(authored, key)
+    return authored
+
+
+def may_evaluate(value: Any, authored: Any) -> bool:
+    """True when ``value`` is a template the author wrote at this position, unchanged."""
+    if not isinstance(value, str):
+        return False
+    if authored is LEGACY:
+        return True
+    return isinstance(authored, str) and value == authored
+
+
+def copy_containers(value: Any) -> Any:
+    """Rebuild dicts/lists (leaves shared) without evaluating anything."""
+    if isinstance(value, dict):
+        return {k: copy_containers(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [copy_containers(v) for v in value]
+    return value
+
+
+class _Literal:
+    """Opaque wrapper that hides runtime data from ``ExpressionEvaluator.evaluate_fields``."""
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: Any) -> None:
+        self.value = value
+
+
+def shield(value: Any, authored: Any) -> Any:
+    """Wrap every non-authored position so ``evaluate_fields`` leaves it untouched."""
+    if authored is LEGACY:
+        return value
+    if isinstance(value, str):
+        if "{{" in value and not may_evaluate(value, authored):
+            return _Literal(value)
+        return value
+    if isinstance(value, dict):
+        if isinstance(authored, dict):
+            return {k: shield(v, authored.get(k, NOT_AUTHORED)) for k, v in value.items()}
+        return _Literal(value)
+    if isinstance(value, list):
+        if isinstance(authored, list) and len(authored) == len(value):
+            return [shield(v, a) for v, a in zip(value, authored)]
+        return _Literal(value)
+    return value
+
+
+def _rebuild_like_evaluate_fields(value: Any) -> Any:
+    # evaluate_fields rebuilds dicts recursively and lists one level deep.
+    if isinstance(value, dict):
+        return {k: _rebuild_like_evaluate_fields(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return list(value)
+    return value
+
+
+def unshield(value: Any, authored: Any) -> Any:
+    """Undo ``shield`` along the authored structure (resolved data is not walked)."""
+    if isinstance(value, _Literal):
+        return _rebuild_like_evaluate_fields(value.value)
+    if authored is LEGACY:
+        return value
+    if isinstance(value, dict) and isinstance(authored, dict):
+        return {k: unshield(v, authored.get(k, NOT_AUTHORED)) for k, v in value.items()}
+    if isinstance(value, list) and isinstance(authored, list) and len(value) == len(authored):
+        return [unshield(v, a) for v, a in zip(value, authored)]
+    return value
+
+
+def shield_config(config: Dict[str, Any], authored: Any) -> Dict[str, Any]:
+    return {k: shield(v, child(authored, k)) for k, v in config.items()}
+
+
+def unshield_config(config: Dict[str, Any], authored: Any) -> Dict[str, Any]:
+    return {k: unshield(v, child(authored, k)) for k, v in config.items()}
+
+
+def evaluate_fields_authored(evaluator: Any, fields: Dict[str, Any], authored: Any, on_error: Any = None) -> Dict[str, Any]:
+    """``ExpressionEvaluator.evaluate_fields`` limited to authored templates."""
+    shielded = shield_config(fields, authored)
+    if on_error is None:
+        resolved = evaluator.evaluate_fields(shielded)
+    else:
+        resolved = evaluator.evaluate_fields(shielded, on_error=on_error)
+    return unshield_config(resolved, authored)

{programgarden-2.6.5 → programgarden-2.6.7}/programgarden/context.py

@@ -331,8 +331,34 @@ class ExecutionContext:
         # warn-and-continue behaviour untouched).
         self._deep_unresolved_bindings: List[Dict[str, str]] = []
 
+        # Authored node configs (deep copies of the workflow definition). Only a
+        # template still at its authored position is evaluated; everything a node
+        # run produces is data. See programgarden.binding_provenance.
+        self._authored_node_configs: Dict[str, Dict[str, Any]] = {}
+
         self._build_dag_index(workflow_edges, workflow_nodes)
 
+    # === Authored config (expression provenance) ===
+
+    def register_authored_node_configs(self, workflow: Any) -> None:
+        """Snapshot every node's authored config from a resolved workflow."""
+        from programgarden.binding_provenance import authored_snapshot
+
+        nodes = getattr(workflow, "nodes", None)
+        if not isinstance(nodes, dict):
+            return
+        for node_id, node in nodes.items():
+            config = getattr(node, "config", None)
+            if not isinstance(config, dict):
+                continue
+            self._authored_node_configs[node_id] = authored_snapshot(
+                getattr(node, "node_type", ""), config, getattr(node, "fields", None),
+            )
+
+    def authored_node_config(self, node_id: str) -> Optional[Dict[str, Any]]:
+        """Authored config snapshot of ``node_id``; None when the node has none."""
+        return self._authored_node_configs.get(node_id)
+
     # === Storage Directory ===
 
     def _resolve_db_path(self, db_filename: str) -> str: