programgarden 2.6.5__tar.gz → 2.6.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.6.5
+Version: 2.6.6
 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.3,<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,13 @@ The 2.6.2 release candidate [futures minute alias correction](../../docs/futures
 
 # ProgramGarden
 
+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.
@@ -307,7 +314,7 @@ job = await pg.run_async(
 
 ## 주요 특징
 
-- **노드 기반 DSL**: 72개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
+- **노드 기반 DSL**: 74개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
 - **실시간 처리**: WebSocket 기반 실시간 시세, 계좌, 체결 이벤트 수신
 - **AI Agent 통합**: LLMModelNode + AIAgentNode로 LLM 기반 분석/의사결정
 - **플러그인 확장**: 67개 내장 전략 플러그인 (RSI, MACD, 볼린저밴드, 이치모쿠, 듀얼모멘텀, 터틀브레이크아웃 등)
@@ -319,7 +326,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.6}/README.md

@@ -2,6 +2,13 @@ The 2.6.2 release candidate [futures minute alias correction](../../docs/futures
 
 # ProgramGarden
 
+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.
@@ -278,7 +285,7 @@ job = await pg.run_async(
 
 ## 주요 특징
 
-- **노드 기반 DSL**: 72개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
+- **노드 기반 DSL**: 74개 내장 노드를 조합하여 코딩 없이 자동매매 전략 구성
 - **실시간 처리**: WebSocket 기반 실시간 시세, 계좌, 체결 이벤트 수신
 - **AI Agent 통합**: LLMModelNode + AIAgentNode로 LLM 기반 분석/의사결정
 - **플러그인 확장**: 67개 내장 전략 플러그인 (RSI, MACD, 볼린저밴드, 이치모쿠, 듀얼모멘텀, 터틀브레이크아웃 등)
@@ -290,7 +297,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.6/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.6}/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: