programgarden-core 2.0.1__tar.gz → 2.1.0__tar.gz

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden-core
-Version: 2.0.1
+Version: 2.1.0
 Summary: ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/code_node.py

@@ -104,9 +104,11 @@ FORBIDDEN_ATTR_NAMES: frozenset = frozenset({
 })
 
 # ── Denylist: introspection-escape / exfiltration dunders & frame attrs ──────
-# NOTE: enforcement is the BLANKET underscore rule in _scan_ast (any attribute
-# or string beginning with '_' is rejected), which subsumes every dunder. This
-# explicit set is retained for documentation / message clarity.
+# NOTE: enforcement is the underscore rule in _scan_ast — any ATTRIBUTE beginning
+# with '_' is rejected (subsumes every dunder and private module re-export like
+# random._os); STRING literals are rejected when they contain a dunder or name a
+# blocked attribute re-export (bare single-underscore data-key strings such as
+# "_partial_failure" are allowed). This explicit set is retained for message clarity.
 FORBIDDEN_DUNDERS: frozenset = frozenset({
     "__class__", "__bases__", "__base__", "__subclasses__", "__mro__",
     "__globals__", "__code__", "__closure__", "__func__", "__self__",
@@ -224,12 +226,18 @@ def _scan_ast(tree: ast.AST, allowed_imports: Set[str]) -> List[Dict[str, Any]]:
         elif isinstance(node, ast.Constant) and isinstance(node.value, str):
             v = node.value
             bad = None
-            if v.startswith("_"):
-                bad = f"string literal '{v}' begins with '_' (introspection escape)"
-            elif "__" in v:
-                bad = f"string literal contains a dunder (introspection escape)"
-            elif v in FORBIDDEN_ATTR_NAMES:
-                bad = f"string literal '{v}' names a blocked attribute"
+            # A single leading underscore names a documented native data marker
+            # read as a dict key (e.g. balance["_partial_failure"], "_source"),
+            # so it is allowed. Still rejected: dunder-style names, and blocked
+            # public/underscored attribute re-exports ("os"/"sys"/"system"/"_os"/
+            # "_sys"... -> in FORBIDDEN_ATTR_NAMES via lstrip("_")), and attribute-
+            # walking format fields. getattr/attrgetter/operator/format are
+            # independently blocked, so a bare underscore data-key string cannot
+            # be turned into attribute access.
+            if "__" in v:
+                bad = "string literal contains a dunder (introspection escape)"
+            elif v.lstrip("_") in FORBIDDEN_ATTR_NAMES:
+                bad = f"string literal '{v}' names a blocked attribute (introspection escape)"
             elif _FORMAT_ATTR_RE.search(v):
                 bad = "format string performs attribute access (introspection escape)"
             if bad:

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/expression/evaluator.py

@@ -56,6 +56,8 @@ def _get_nested_value(obj: Any, path: str) -> Any:
             return None
         if isinstance(current, dict):
             current = current.get(key)
+        elif isinstance(current, NodeOutputProxy) and isinstance(current._data, dict) and key in current._data:
+            current = current._data[key]  # port before helper method (see _eval_node)
         else:
             current = getattr(current, key, None)
     return current
@@ -941,6 +943,15 @@ class SafeEvaluator:
             obj = self._eval_node(node.value)
             if isinstance(obj, dict):
                 return obj.get(node.attr)
+            # An output PORT wins over a proxy helper of the same name: a node
+            # whose port is called `count` (OpenOrdersNode), `sum`, `first`, `last`,
+            # `map` or `filter` must resolve to the port value, not to the bound
+            # helper method (observed 2026-09-24: `{{ nodes.open_orders.count }}`
+            # returned `NodeOutputProxy.count` and the CodeNode input could not be
+            # serialized — "Object of type method is not JSON serializable").
+            if isinstance(obj, NodeOutputProxy) and isinstance(obj._data, dict) and node.attr in obj._data:
+                value = obj._data[node.attr]
+                return NodeOutputProxy(value) if isinstance(value, list) else value
             return getattr(obj, node.attr, None)
 
         # 인덱싱 (arr[0], dict["key"])
@@ -952,6 +963,15 @@ class SafeEvaluator:
         # 함수 호출
         if isinstance(node, ast.Call):
             func = self._eval_node(node.func)
+            if not callable(func) and isinstance(node.func, ast.Attribute):
+                # `{{ nodes.open_orders.count() }}`: the bare attribute resolves to
+                # the `count` PORT (see the Attribute branch), but a CALL of that
+                # name still means the proxy helper, so workflows written against
+                # the helper keep working on nodes that also declare the port.
+                owner = self._eval_node(node.func.value)
+                helper = getattr(owner, node.func.attr, None) if isinstance(owner, NodeOutputProxy) else None
+                if callable(helper):
+                    func = helper
             if not callable(func):
                 raise ExpressionError(f"호출 불가능한 객체: {func}")
             args = [self._eval_node(arg) for arg in node.args]

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/i18n/locales/en.json

@@ -291,7 +291,7 @@
   "fields.CurrencyRateNode.target_currencies": "Target currencies. Select currencies to get exchange rates against the base currency.",
   "fields.CurrencyRateNode.timeout_seconds": "API request timeout (seconds). Default 30s, adjust based on your network conditions.",
   "fields.CodeNode.code": "Python source that defines async def execute(data, params, context). Sandboxed: only pure-computation stdlib imports (math, statistics, json, datetime, ...) are allowed; no credentials, network, filesystem, or introspection.",
-  "fields.CodeNode.outputs": "Output port declarations [{name, type}]. Leave empty for a single 'result' port carrying the whole return value. Declared ports are consumed downstream by {{ nodes.<id>.<port> }} expressions written into a consumer's generic input field (TableDisplayNode.data, IfNode.left/right, ...), not by typed-port matching; declaring them enables static typo-guarding.",
+  "fields.CodeNode.outputs": "Output port declarations [{name, type}]. Leave empty for a single 'result' port carrying the whole return value: return 3 yields result=3; return {'result':3} yields result={'result':3}. Declare [{name:'result',type:'number'}] to map a returned dict's result key to the number port. Declared ports are consumed downstream by {{ nodes.<id>.<port> }} expressions written into a consumer's generic input field (TableDisplayNode.data, IfNode.left/right, ...), not by typed-port matching; declaring them enables static typo-guarding.",
   "fields.CodeNode.params": "Parameters passed to execute() as `params`. Expression bindings are allowed (e.g. a period or threshold).",
   "fields.CodeNode.data": "Input data passed to execute() as `data`. Bind the whole upstream value (e.g. {{ nodes.hist.values }}) and loop over it inside the function.",
   "fields.FieldMappingNode.data": "Input data to transform. Bind from HTTPRequestNode response or other node outputs.",

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/i18n/locales/ko.json

@@ -291,7 +291,7 @@
   "fields.CurrencyRateNode.target_currencies": "대상 통화 목록. 기준 통화 대비 환율을 조회할 통화를 선택하세요.",
   "fields.CurrencyRateNode.timeout_seconds": "API 요청 타임아웃 (초). 기본 30초, 네트워크 환경에 따라 조정하세요.",
   "fields.CodeNode.code": "async def execute(data, params, context) 를 정의하는 파이썬 소스. 샌드박스: 순수 계산용 표준 라이브러리(math, statistics, json, datetime, ...) import 만 허용, credential·네트워크·파일시스템·introspection 불가.",
-  "fields.CodeNode.outputs": "출력 포트 선언 [{name, type}]. 비워두면 반환값 전체를 담는 단일 'result' 포트가 됩니다. 선언한 포트는 소비자 노드의 범용 입력 필드(TableDisplayNode.data, IfNode.left/right 등)에 {{ nodes.<id>.<port> }} 표현식으로 소비됩니다 — 타입드 포트 매칭이 아니라 이름으로 dict 키를 꺼내는 방식. 선언하면 정적 오타 검증이 적용됩니다.",
+  "fields.CodeNode.outputs": "출력 포트 선언 [{name, type}]. 비워두면 반환값 전체를 담는 단일 'result' 포트가 됩니다. 선언한 포트는 소비자 노드의 범용 입력 필드(TableDisplayNode.data, IfNode.left/right 등)에 {{ nodes.<id>.<port> }} 표현식으로 소비됩니다 — 타입드 포트 매칭이 아니라 이름으로 dict 키를 꺼내는 방식. 선언하면 정적 오타 검증이 적용됩니다. outputs를 비우면 반환값 전체가 result입니다. return 3은 result=3, return {'result':3}은 result={'result':3}이 됩니다. 반환 딕셔너리의 result 키를 숫자 포트로 사용하려면 outputs에 name:result, type:number를 선언하세요.",
   "fields.CodeNode.params": "execute() 에 `params` 로 전달되는 파라미터. 표현식 바인딩 허용(예: 기간·임계값).",
   "fields.CodeNode.data": "execute() 에 `data` 로 전달되는 입력 데이터. 상류 값 전체를 바인딩(예: {{ nodes.hist.values }})하고 함수 안에서 반복하세요.",
   "fields.FieldMappingNode.data": "변환할 입력 데이터. HTTPRequestNode 응답이나 다른 노드 출력을 바인딩하세요.",

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/account_korea_stock.py

@@ -111,7 +111,7 @@ class KoreaStockAccountNode(BaseNode):
                     }
                 ],
             },
-            "expected_output": "positions port: list of {symbol, quantity, avg_price, pnl_rate} in KRW; balance port: {cash_krw, total_eval_krw, orderable_amount}; held_symbols: [{symbol}].",
+            "expected_output": "positions: observed holdings with symbol, quantity, avg_price, pnl_rate and cost/P&L availability; missing money stays null. balance: {deposit, total_eval, orderable_amount} in KRW; held_symbols: [{exchange, symbol}].",
         },
         {
             "title": "Cash check before Korea stock order",

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/base.py

@@ -328,7 +328,7 @@ OVERSEAS_STOCK_POSITION_FIELDS: List[Dict[str, str]] = [
     {"name": "market", "type": "string", "description": "시장 구분명"},
 ]
 
-# 국내주식 REST 계좌 (t0424)
+# Domestic REST account: observed CSPAQ12300 evidence plus executor aliases.
 KOREA_STOCK_POSITION_FIELDS: List[Dict[str, str]] = [
     {"name": "exchange", "type": "string", "description": "거래소 코드 (항상 KRX)"},
     {"name": "symbol", "type": "string", "description": "종목코드"},
@@ -342,6 +342,20 @@ KOREA_STOCK_POSITION_FIELDS: List[Dict[str, str]] = [
     {"name": "sellable_qty", "type": "number", "description": "매도 가능 수량"},
     {"name": "eval_amount", "type": "number", "description": "평가 금액"},
     {"name": "product", "type": "string", "description": "상품 구분 (항상 korea_stock)"},
+    {"name": "symbol_name", "type": "string", "description": "Observed instrument name; name alias uses the same value"},
+    {"name": "currency", "type": "string", "description": "Valuation currency: KRW"},
+    {"name": "buy_price", "type": "number", "description": "Observed average acquisition price; null when unavailable"},
+    {"name": "average_price", "type": "number", "description": "Observed average acquisition price; null when unavailable"},
+    {"name": "acquisition_amount", "type": "number", "description": "Observed acquisition amount; null when unavailable"},
+    {"name": "purchase_amount", "type": "number", "description": "Acquisition amount alias; null when unavailable"},
+    {"name": "pnl_rate_basis", "type": "string", "description": "Broker average cost basis, commission excluded"},
+    {"name": "pnl_rate_status", "type": "string", "description": "available or unavailable; missing evidence is not zero return"},
+    {"name": "pnl_status", "type": "string", "description": "available or unavailable"},
+    {"name": "pnl_unavailable_reason", "type": "string", "description": "Missing P&L evidence reason; null when available"},
+    {"name": "cost_basis", "type": "string", "description": "Broker average cost basis, commission excluded"},
+    {"name": "cost_status", "type": "string", "description": "available or unavailable"},
+    {"name": "cost_unavailable_reason", "type": "string", "description": "Missing acquisition evidence reason; null when available"},
+    {"name": "observed_at", "type": "string", "description": "UTC ISO observation timestamp"},
 ]
 
 # 해외선물 REST 계좌 (CIDBQ01500 block2)
@@ -1030,4 +1044,4 @@ class BaseMessagingNode(BaseNode):
                 category=FieldCategory.SETTINGS,
                 depends_on={"resilience.fallback.mode": "default_value"},
             ),
-        }
+        }

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/code.py

@@ -69,8 +69,10 @@ class CodeNode(BaseNode):
     - `context` = a READ-ONLY scrubbed context: safe helper namespaces
       (`context.date/finance/stats/format/lst`), a risk-tracker read snapshot,
       and workflow meta. It exposes NO credentials, broker, or executor.
-    - Return a dict; its keys map to the declared `outputs` ports. If `outputs`
-      is omitted, the entire return value is exposed on a single `result` port.
+    - With declared `outputs`, return a dict keyed by those ports. A single
+      declared port also accepts a scalar. With no declaration, the WHOLE return
+      value becomes `result`: return 3 gives result=3; return {'result': 3}
+      gives result={'result': 3}, not result=3.
 
     Example DSL:
         {
@@ -108,9 +110,15 @@ class CodeNode(BaseNode):
     outputs: List[Dict[str, str]] = Field(
         default_factory=list,
         description=(
-            "Output port declarations [{name, type}]. Empty → single 'result' port. "
+            "Output port declarations [{name, type}]. Empty exposes the WHOLE return on result: "
+            "return 3 gives result=3; return {'result': 3} gives result={'result': 3}. "
+            "With outputs=[{name:'result',type:'number'}], return {'result':3} gives result=3. "
             "Declared ports are consumed downstream by {{ nodes.<id>.<port> }} expressions, "
-            "not by typed-port matching; declaring them enables static typo-guarding."
+            "not by typed-port matching; declaring them enables static typo-guarding. "
+            "Do NOT name a port 'error' or 'reason': the engine treats a top-level 'error' "
+            "value (and a top-level 'reason' of no_symbol/no_price/invalid_input) as a node "
+            "failure, so such a port makes a successful return read as an engine error. Put "
+            "any status/diagnostic under a differently named port or nested object instead."
         ),
     )
 
@@ -174,9 +182,14 @@ class CodeNode(BaseNode):
         },
         {
             "pattern": "Declaring 'outputs' ports whose names the return dict never sets",
-            "reason": "A declared port missing from the return maps to None with a warning — a silent-looking gap downstream.",
+            "reason": "Deep/replay validation rejects missing declared ports and values that violate their declared types. Legacy live mapping to None is not evidence of a valid output.",
             "alternative": "Return a dict whose keys exactly match every declared output port name.",
         },
+        {
+            "pattern": "Naming a declared output port 'error' or 'reason'",
+            "reason": "The engine (live runtime and replay) treats a top-level 'error' value, and a top-level 'reason' of no_symbol/no_price/invalid_input, as a node failure. A port with either name makes the node's own successful output read as an engine execution error, and no calculation defect exists to repair.",
+            "alternative": "Rename the port (e.g. 'status', 'note', 'detail') or nest status inside another object such as {'result': {...}}; keep 'error'/'reason' out of the top-level return.",
+        },
         {
             "pattern": "Feeding a CodeNode return of non-standard shape into a typed node (order node, ConditionNode)",
             "reason": "The binding layer checks port existence but never coerces shape; a wrong shape does not fail at the CodeNode — it fails downstream where the typed node reads it (e.g. order nodes expect the Symbol Data Format array of {symbol, exchange, ...}).",
@@ -347,7 +360,7 @@ class CodeNode(BaseNode):
     ]
     _node_guide: ClassVar[Dict[str, Any]] = {
         "input_handling": "SINGLE upstream: bind the whole upstream value to 'data' (e.g. \"{{ nodes.hist.values }}\") and loop over it inside execute() — CodeNode is not per-item auto-iterated. MULTIPLE upstreams (2+ producers feeding this node — fully supported): 'data' holds ONE whole value, so do NOT try to merge producers into it. Keep an edge from EACH producer and bind EACH upstream value to its own key under 'params' — params values are expression-bindable: \"params\": {\"fgi_value\": \"{{ nodes.fgi.value }}\", \"vix_response\": \"{{ nodes.vix_http.response }}\"} — then read them with params.get('fgi_value', 50) inside execute(). params.get(...) is the normal, always-allowed way to read bound inputs. 'params' also carries fixed knobs (literals). Declare 'outputs' when you want named ports; omit it to use the single 'result' port.",
-        "output_consumption": "Downstream nodes do NOT need a matching typed port. They consume a CodeNode output by writing a {{ nodes.<id>.<port> }} expression into their own generic input field (e.g. TableDisplayNode.data, IfNode.left/right, FieldMappingNode.data) — the binding layer resolves the dict key by name, it does not type-match ports. With no outputs declared, read {{ nodes.<id>.result }} (the whole return value). A declared output port that no node references is fine; a declared port absent from the return dict resolves to None with a warning. Because ports are declared, validate() typo-guards these references.",
+        "output_consumption": "Downstream nodes do NOT need a matching typed port. They consume a CodeNode output by writing a {{ nodes.<id>.<port> }} expression into their own generic input field (e.g. TableDisplayNode.data, IfNode.left/right, FieldMappingNode.data) — the binding layer resolves the dict key by name, it does not type-match ports. With no outputs declared, read {{ nodes.<id>.result }} (the whole return value). A declared output port that no node references is fine; a declared port absent from the return dict fails deep/replay validation. Do not rely on legacy live None substitution. Because ports are declared, validate() typo-guards these references.",
         "common_combinations": [
             "CodeNode → TableDisplayNode / LineChartNode / TelegramNode (display or sink — any return shape works)",
             "CodeNode → OverseasStockNewOrderNode / ConditionNode (typed node — return the standard [{symbol, exchange, ...}] shape)",
@@ -362,7 +375,7 @@ class CodeNode(BaseNode):
             "sandbox, and I/O/system stdlib (os, sys, socket, subprocess, urllib, http, requests, open) is "
             "blocked. Re-implement such functionality by hand in pure Python using the allowed stdlib.",
             "No credential/broker/network access — CodeNode cannot place orders or fetch data itself; feed it data from typed nodes.",
-            "Declared output ports must all appear as keys in the returned dict, or they resolve to None.",
+            "Every declared output must be present and match its type in deep/replay validation. A single declared port also supports a scalar return.",
             "There is NO one-upstream limit. Only the `data` field carries a single whole value — "
             "the node accepts any number of upstream producers. With 2+ producers, keep an edge "
             "from each and bind each value to its own `params` key "
@@ -440,7 +453,7 @@ class CodeNode(BaseNode):
                 expression_mode=ExpressionMode.FIXED_ONLY,
                 category=FieldCategory.PARAMETERS,
                 ui_component=UIComponent.CUSTOM_CODE_EDITOR,
-                example="async def execute(data, params, context):\n    return {'result': data}",
+                example="async def execute(data, params, context):\n    return data",
                 expected_type="str",
                 help_text=(
                     "Define async def execute(data, params, context). Sandboxed: no "

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/data.py

@@ -212,7 +212,7 @@ class SQLiteNode(BaseNode):
                         "operation": "simple",
                         "table": "hwm",
                         "action": "upsert",
-                        "values": {"symbol": "{{ nodes.market.value.symbol }}", "peak": '{{ nodes.market.value.price }}'},
+                        "values": {"symbol": "{{ nodes.market.values[0].symbol }}", "peak": '{{ nodes.market.values[0].price }}'},
                         "on_conflict": "symbol",
                     },
                     {

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/data_futures.py

@@ -196,8 +196,6 @@ class OverseasFuturesMarketDataNode(BaseNode):
         InputPort(name="trigger", type="signal", description="i18n:ports.trigger", required=False),
     ]
     _outputs: List[OutputPort] = [
-        OutputPort(name="value", type="market_data", description="i18n:ports.market_data_value",
-                   fields=FUTURES_REST_PRICE_FIELDS),
         OutputPort(
             name="values",
             type="array",
@@ -206,9 +204,9 @@ class OverseasFuturesMarketDataNode(BaseNode):
         ),
     ]
 
-    _version: ClassVar[str] = "1.0.0"
-    _updated_at: ClassVar[str] = "2026-05-19"
-    _change_note: ClassVar[Optional[str]] = None
+    _version: ClassVar[str] = "1.0.1"
+    _updated_at: ClassVar[str] = "2026-09-23"
+    _change_note: ClassVar[Optional[str]] = "Remove nonexistent singular quote output; bind the values array."
 
     @classmethod
     def get_field_schema(cls) -> Dict[str, "FieldSchema"]:

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/data_korea_stock.py

@@ -195,7 +195,6 @@ class KoreaStockMarketDataNode(BaseNode):
         InputPort(name="trigger", type="signal", description="i18n:ports.trigger", required=False),
     ]
     _outputs: List[OutputPort] = [
-        OutputPort(name="value", type="market_data", description="i18n:ports.market_data_value", fields=KOREA_STOCK_PRICE_DATA_FIELDS),
         OutputPort(
             name="values",
             type="array",
@@ -204,9 +203,9 @@ class KoreaStockMarketDataNode(BaseNode):
         ),
     ]
 
-    _version: ClassVar[str] = "1.0.0"
-    _updated_at: ClassVar[str] = "2026-05-19"
-    _change_note: ClassVar[Optional[str]] = None
+    _version: ClassVar[str] = "1.0.1"
+    _updated_at: ClassVar[str] = "2026-09-23"
+    _change_note: ClassVar[Optional[str]] = "Remove nonexistent singular quote output; bind the values array."
 
     @classmethod
     def get_field_schema(cls) -> Dict[str, "FieldSchema"]:

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/data_stock.py

@@ -196,26 +196,6 @@ class OverseasStockMarketDataNode(BaseNode):
         InputPort(name="trigger", type="signal", description="i18n:ports.trigger", required=False),
     ]
     _outputs: List[OutputPort] = [
-        OutputPort(
-            name="value",
-            type="market_data",
-            description="i18n:ports.market_data_value",
-            fields=PRICE_DATA_FIELDS,
-            example={
-                "symbol": "AAPL",
-                "exchange": "NASDAQ",
-                "price": 187.45,
-                "change": -2.34,
-                "change_pct": -1.23,
-                "volume": 12_345_678,
-                "open": 189.10,
-                "high": 190.02,
-                "low": 186.90,
-                "close": 187.45,
-                "per": 28.5,
-                "eps": 6.57,
-            },
-        ),
         OutputPort(
             name="values",
             type="array",
@@ -224,9 +204,9 @@ class OverseasStockMarketDataNode(BaseNode):
         ),
     ]
 
-    _version: ClassVar[str] = "1.0.0"
-    _updated_at: ClassVar[str] = "2026-05-19"
-    _change_note: ClassVar[Optional[str]] = None
+    _version: ClassVar[str] = "1.0.1"
+    _updated_at: ClassVar[str] = "2026-09-23"
+    _change_note: ClassVar[Optional[str]] = "Remove nonexistent singular quote output; bind the values array."
 
     @classmethod
     def get_field_schema(cls) -> Dict[str, "FieldSchema"]:

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/display.py

@@ -190,7 +190,7 @@ class TableDisplayNode(BaseDisplayNode):
         {
             "pattern": "Binding a single dict (not a list) to TableDisplayNode data",
             "reason": "TableDisplayNode expects list[dict]. A plain dict renders as a single-column table with keys, which is rarely useful.",
-            "alternative": "Wrap single records in a list ([{{ nodes.market.value }}]) or use SummaryDisplayNode for single-object display.",
+            "alternative": "Wrap single records in a list ([{{ nodes.market.values[0] }}]) or use SummaryDisplayNode for single-object display.",
         },
         {
             "pattern": "Setting limit=100 for a live dashboard that updates every second",

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/order.py

@@ -389,7 +389,7 @@ class OverseasStockNewOrderNode(BaseOrderNode):
         "Supports extended price_type options: LOO, LOC, MOO, MOC for open/close auction orders",
         "is_tool_enabled=True — AI Agent can call this node as a tool to place orders autonomously",
         "retry is disabled by default (resilience.retry.enabled=False); only pure network-connection failures may be retried, never a submitted order",
-        "US daytime (Blue Ocean) session accepts LIMIT orders only — a market order is refused at intake with rsp_cd=00891 and no order number. A workflow scheduled across both the daytime and the regular overnight session must therefore use order_type='limit' for it to work in both.",
+        "US daytime (Blue Ocean) session accepts LIMIT orders only — a market order is refused at intake with rsp_cd=00891 and no order number (00891 is a generic order-price rejection: it was also observed on 2026-09-24 for a price of 1 USD or more sent with more than two decimals — '주문단가 오류. $1이상은 소수점 2째 자리까지 입력가능합니다'). A workflow scheduled across both the daytime and the regular overnight session must therefore use order_type='limit' for it to work in both.",
         "A limit order needs a price. Buy orders fall back to a current-price lookup, and so do sell orders since engine 1.37.3, but that lookup (g3101) only accepts exchange codes 81/82 — it fails for a holding listed on any other market. Prefer feeding the price the account balance already carries: price='{{ item.current_price }}'.",
     ]
     _anti_patterns: ClassVar[List[Dict[str, str]]] = [
@@ -438,7 +438,7 @@ class OverseasStockNewOrderNode(BaseOrderNode):
                     {"id": "market", "type": "OverseasStockMarketDataNode", "symbols": [{"symbol": "AAPL", "exchange": "NASDAQ"}], "fields": ["price"]},
                     {"id": "historical", "type": "OverseasStockHistoricalDataNode", "symbols": [{"symbol": "AAPL", "exchange": "NASDAQ"}], "period": "1d", "count": 20},
                     {"id": "condition", "type": "ConditionNode", "plugin": "RSI", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"period": 14, "oversold_threshold": 30}},
-                    {"id": "sizing", "type": "PositionSizingNode", "method": "fixed_percent", "max_percent": 5, "balance": "{{ nodes.account.balance }}", "price": '{{ nodes.market.value.price }}', "symbol": {"symbol": "AAPL", "exchange": "NASDAQ"}},
+                    {"id": "sizing", "type": "PositionSizingNode", "method": "fixed_percent", "max_percent": 5, "balance": "{{ nodes.account.balance }}", "price": '{{ nodes.market.values[0].price }}', "symbol": {"symbol": "AAPL", "exchange": "NASDAQ"}},
                     {"id": "order", "type": "OverseasStockNewOrderNode", "side": "buy", "order_type": "limit", "order": "{{ nodes.sizing.order }}"},
                 ],
                 "edges": [

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/risk.py

@@ -257,7 +257,7 @@ class PositionSizingNode(BaseNode):
                         "max_percent": 10.0,
                         "symbols": [{"symbol": "AAPL", "exchange": "NASDAQ"}],
                         "balance": "{{ nodes.account.balance }}",
-                        "market_data": "{{ nodes.market.value }}",
+                        "market_data": "{{ nodes.market.values }}",
                     },
                     {"id": "display", "type": "SummaryDisplayNode", "title": "Sized orders", "data": {"orders": "{{ nodes.size.orders }}"}},
                 ],

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/symbol.py

@@ -113,7 +113,7 @@ class WatchlistNode(BaseNode):
                     {"id": "watchlist", "type": "WatchlistNode", "symbols": [{"symbol": "AAPL", "exchange": "NASDAQ"}, {"symbol": "MSFT", "exchange": "NASDAQ"}, {"symbol": "NVDA", "exchange": "NASDAQ"}]},
                     {'id': 'split', 'type': 'SplitNode', 'array': '{{ nodes.watchlist.symbols }}'},
                     {"id": "market", "type": "OverseasStockMarketDataNode", "symbol": "{{ nodes.split.item }}"},
-                    {"id": "display", "type": "TableDisplayNode", "data": "{{ nodes.market.value }}"},
+                    {"id": "display", "type": "TableDisplayNode", "data": "{{ nodes.market.values }}"},
                 {'id': 'split_results', 'type': 'AggregateNode', 'mode': 'collect'}],
                 "edges": [
                     {"from": "start", "to": "broker"},
@@ -392,7 +392,7 @@ class ScreenerNode(BaseNode):
     description: str = "i18n:nodes.ScreenerNode.description"
 
     # 입력 종목 리스트 (선택사항) - 바인딩 또는 직접 입력
-    symbols: Optional[Union[List[Dict[str, str]], str]] = Field(
+    symbols: Optional[Union[List[Dict[str, Any]], str]] = Field(
         default=None,
         description="필터링할 종목 리스트. 없으면 전체 시장에서 검색",
     )
@@ -592,6 +592,10 @@ class ScreenerNode(BaseNode):
             "KoreaStockBrokerNode → KoreaStockSymbolQueryNode → ScreenerNode(market='korea_stock') → SplitNode",
         ],
         "pitfalls": [
+            "LS screening requires an explicit exchange for each symbol and a connected broker credential. It does not guess NASDAQ for unknown exchanges.",
+            "LS sector filtering is unsupported: choose data_source='yfinance' for sector names. A sector condition is never silently removed in LS mode.",
+            "LS market-cap filters require numeric market_cap from a g3190 master upstream. A watchlist plus g3101 cannot supply market cap; missing data raises an error.",
+            "Valid observations with no matching symbols produce count=0. Missing quotes, wrong response identity or unavailable filter data are errors, not a no-signal result.",
             "ScreenerNode relies on Yahoo Finance data (or LS g3190/g3101 for overseas_stock) which may have delays or inconsistencies with realtime broker data.",
             "Setting no filters returns all symbols up to max_results — always set at least one filter for production strategies.",
             "data_source='ls' is only effective for overseas_stock. Other markets log a warning and fall back to yfinance — set data_source='yfinance' explicitly to silence the warning.",
@@ -600,9 +604,9 @@ class ScreenerNode(BaseNode):
         ],
     }
 
-    _version: ClassVar[str] = "1.0.0"
-    _updated_at: ClassVar[str] = "2026-05-19"
-    _change_note: ClassVar[Optional[str]] = None
+    _version: ClassVar[str] = "1.1.0"
+    _updated_at: ClassVar[str] = "2026-09-23"
+    _change_note: ClassVar[Optional[str]] = "Preserve numeric master fields; bind LS quotes and fail unavailable filters without treating zero matches as errors."
 
     @classmethod
     def get_field_schema(cls) -> Dict[str, "FieldSchema"]:

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/symbol_futures.py

@@ -133,7 +133,7 @@ class OverseasFuturesSymbolQueryNode(BaseNode):
                     {"id": "symbols", "type": "OverseasFuturesSymbolQueryNode", "futures_exchange": "6", "futures_contract_month": "front", "max_results": 50},
                     {'id': 'split', 'type': 'SplitNode', 'array': '{{ nodes.symbols.symbols }}'},
                     {"id": "market", "type": "OverseasFuturesMarketDataNode", "symbol": "{{ nodes.split.item }}"},
-                    {"id": "display", "type": "TableDisplayNode", "data": "{{ nodes.market.value }}"},
+                    {"id": "display", "type": "TableDisplayNode", "data": "{{ nodes.market.values }}"},
                 {'id': 'split_results', 'type': 'AggregateNode', 'mode': 'collect'}],
                 "edges": [
                     {"from": "start", "to": "broker"},

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/programgarden_core/nodes/trigger.py

@@ -115,7 +115,7 @@ class ScheduleNode(BaseNode):
         {
             "pattern": "No TradingHoursFilterNode downstream for time-sensitive trading",
             "reason": "Cron fires exactly at the cron cadence, including weekends and holidays; orders may slip onto a closed market.",
-            "alternative": "Chain `ScheduleNode → TradingHoursFilterNode (from_port='passed') → trading body` so cron-after-hours is silently blocked.",
+            "alternative": "Use SessionGateNode → IfNode for immediate off-hours refusal, or TradingHoursFilterNode to wait until the window opens. Neither supplies an exchange holiday calendar.",
         },
     ]
     _examples: ClassVar[List[Dict[str, Any]]] = [
@@ -310,14 +310,14 @@ class TradingHoursFilterNode(BaseNode):
         ],
         "typical_scenarios": [
             "ScheduleNode → TradingHoursFilterNode → trading body (passed branch)",
-            "TradingHoursFilterNode → IfNode(reason='...') for per-reason branching",
+            "TradingHoursFilterNode blocked port → IfNode for timeout handling",
             "Start → TradingHoursFilterNode → long-running realtime subscription (cleanup at close)",
         ],
     }
     _features: ClassVar[List[str]] = [
         "Configurable start / end in HH:MM form and IANA timezone",
         "`days` whitelist supports weekend-only or weekday-only flows",
-        "Dual outputs: `passed` (within hours) and `blocked` (outside) for explicit branching",
+        "Outside the window this node waits; `passed` activates on entry and `blocked` activates only on timeout/shutdown",
         "max_wait_hours safeguards long waits — the node timeouts instead of stalling forever",
     ]
     _anti_patterns: ClassVar[List[Dict[str, str]]] = [
@@ -356,11 +356,11 @@ class TradingHoursFilterNode(BaseNode):
                     {"credential_id": "broker_cred", "type": "broker_ls_overseas_stock", "data": [{"key": "appkey", "value": "", "type": "password", "label": "App Key"}, {"key": "appsecret", "value": "", "type": "password", "label": "App Secret"}]},
                 ],
             },
-            "expected_output": "Cron fires every 5 min; account query runs only during US trading hours on weekdays. Off-hours cycles hit the blocked branch and skip downstream.",
+            "expected_output": "Account query runs after the trading window opens. Outside the window the node waits up to max_wait_hours; timeout skips the trading branch.",
         },
         {
             "title": "Branch on blocked path for after-hours notification",
-            "description": "TradingHoursFilterNode forks: passed branch runs trading body, blocked branch sends an after-hours notice.",
+            "description": "TradingHoursFilterNode waits for the window: passed runs the trading body; blocked handles timeout. Use SessionGateNode plus IfNode for an immediate closed-window decision.",
             "workflow_snippet": {
                 "id": "hours-filter-notify",
                 "name": "Trading hours fork",
@@ -383,12 +383,12 @@ class TradingHoursFilterNode(BaseNode):
                     {"credential_id": "broker_cred", "type": "broker_ls_overseas_stock", "data": [{"key": "appkey", "value": "", "type": "password", "label": "App Key"}, {"key": "appsecret", "value": "", "type": "password", "label": "App Secret"}]},
                 ],
             },
-            "expected_output": "Hourly cron; within hours → account query; outside hours → SummaryDisplay renders the closed notice.",
+            "expected_output": "Within hours → account query; outside hours → wait; on timeout → SummaryDisplay renders the blocked notice.",
         },
     ]
     _node_guide: ClassVar[Dict[str, Any]] = {
         "input_handling": "Trigger edge from upstream (ScheduleNode or StartNode). Window is configured via start / end / timezone / days.",
-        "output_consumption": "`passed` port runs during-hours branches; `blocked` runs after-hours branches. Use edge `from_port` to pick which downstream fires.",
+        "output_consumption": "`passed` and default edges run after entering the window; explicit `blocked` edges run on timeout. Outside the window the node waits first.",
         "common_combinations": [
             "ScheduleNode → TradingHoursFilterNode → trading body",
             "TradingHoursFilterNode → OverseasStockRealMarketDataNode (start realtime only in-hours)",
@@ -413,7 +413,7 @@ class TradingHoursFilterNode(BaseNode):
             "start": FieldSchema(
                 name="start",
                 type=FieldType.STRING,
-                description="Start time in HH:MM format (24-hour). Signals before this time are blocked.",
+                description="Start time in HH:MM format (24-hour). Wait until the window opens, bounded by max_wait_hours.",
                 default="09:30",
                 required=True,
                 category=FieldCategory.PARAMETERS,
@@ -424,7 +424,7 @@ class TradingHoursFilterNode(BaseNode):
             "end": FieldSchema(
                 name="end",
                 type=FieldType.STRING,
-                description="End time in HH:MM format (24-hour). Signals after this time are blocked.",
+                description="Inclusive end minute in HH:MM format (24-hour). Afterward wait for the next configured window, bounded by max_wait_hours.",
                 default="16:00",
                 required=True,
                 category=FieldCategory.PARAMETERS,
@@ -468,32 +468,37 @@ class TradingHoursFilterNode(BaseNode):
             ),
         }
 
-    def _is_trading_hours(self) -> bool:
-        """Check if current time is within trading hours"""
+    def _is_trading_hours(self, *, as_of: Optional[datetime] = None) -> bool:
+        """Use the live window predicate with an optional aware replay instant."""
+        if as_of is not None and (as_of.tzinfo is None or as_of.utcoffset() is None):
+            raise ValueError("Trading-hours instant must include a timezone")
         try:
             import pytz
         except ImportError:
-            # pytz 없으면 UTC 기준으로 체크
-            now = datetime.utcnow()
-            tz = None
+            from zoneinfo import ZoneInfo
+            tz = ZoneInfo(self.timezone)
         else:
             tz = pytz.timezone(self.timezone)
-            now = datetime.now(tz)
+        now = as_of.astimezone(tz) if as_of is not None else datetime.now(tz)
         
         # 요일 체크
         day_map = {"mon": 0, "tue": 1, "wed": 2, "thu": 3, "fri": 4, "sat": 5, "sun": 6}
-        active_weekdays = [day_map[d.lower()] for d in self.days if d.lower() in day_map]
+        if not self.days or any(d.lower() not in day_map for d in self.days):
+            raise ValueError("Trading days must use explicit weekday names")
+        active_weekdays = [day_map[d.lower()] for d in self.days]
+        # Reject malformed windows even on an inactive weekday.
+        import re
+        # H:MM and HH:MM are both unambiguous ("9:30" was accepted before 2.1.0).
+        if any(not isinstance(value, str) or not re.fullmatch(r"(?:[01]?\d|2[0-3]):[0-5]\d", value)
+               for value in (self.start, self.end)):
+            raise ValueError("Trading-hours window requires HH:MM times")
+        start_h, start_m = map(int, self.start.split(":"))
+        end_h, end_m = map(int, self.end.split(":"))
+        if (end_h, end_m) < (start_h, start_m):
+            raise ValueError("Use SessionGateNode for an overnight window")
         if now.weekday() not in active_weekdays:
             return False
         
-        # 시간 체크
-        try:
-            start_h, start_m = map(int, self.start.split(":"))
-            end_h, end_m = map(int, self.end.split(":"))
-        except ValueError:
-            # 파싱 실패 시 통과
-            return True
-        
         current_minutes = now.hour * 60 + now.minute
         start_minutes = start_h * 60 + start_m
         end_minutes = end_h * 60 + end_m
@@ -513,7 +518,7 @@ class TradingHoursFilterNode(BaseNode):
         # dry_run: 거래시간 대기 없이 즉시 통과
         if getattr(context, "is_dry_run", False):
             context.log("info", "[dry_run] TradingHoursFilter bypassed", self.id)
-            return {"passed": True, "reason": "dry_run_bypass"}
+            return {"passed": True, "blocked": False, "reason": "dry_run_bypass"}
 
         check_interval = 60  # 1분마다 체크
         wait_start = _time.monotonic()
@@ -523,7 +528,7 @@ class TradingHoursFilterNode(BaseNode):
             # graceful shutdown 체크
             if hasattr(context, 'is_running') and not context.is_running:
                 context.log("info", "Shutdown requested, exiting trading hours wait", self.id)
-                return {"passed": False, "reason": "shutdown"}
+                return {"passed": False, "blocked": True, "reason": "shutdown"}
 
             # M-7: max_wait_hours 초과 체크
             if (_time.monotonic() - wait_start) >= max_wait_sec:
@@ -532,10 +537,10 @@ class TradingHoursFilterNode(BaseNode):
                     f"거래시간 대기 timeout: max_wait_hours={self.max_wait_hours}h 초과",
                     self.id,
                 )
-                return {"passed": False, "reason": "timeout"}
+                return {"passed": False, "blocked": True, "reason": "timeout"}
 
             context.log("debug", f"Outside trading hours, waiting... (next check in {check_interval}s)", self.id)
             await asyncio.sleep(check_interval)
 
         context.log("info", "Trading hours active, passing through", self.id)
-        return {"passed": True}
+        return {"passed": True, "blocked": False}

{programgarden_core-2.0.1 → programgarden_core-2.1.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden-core"
-version = "2.0.1"
+version = "2.1.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의"
 readme = "README.md"