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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden-core
-Version: 1.31.1
+Version: 2.1.0
 Summary: ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: pydantic (>=2.0.1,<3.0.0)
 Requires-Dist: tzdata (>=2025.2,<2026.0)
 Description-Content-Type: text/markdown
 
@@ -59,7 +59,7 @@ poetry add programgarden-core
 | analysis | 2 | BacktestEngineNode, BenchmarkCompareNode |
 | ai | 2 | LLMModelNode, AIAgentNode |
 
-> Community adds five nodes: TelegramNode, FearGreedIndexNode, FundamentalDataNode, FileReaderNode and PerformanceReportNode, for 78 total.
+> Community adds four nodes: TelegramNode, FearGreedIndexNode, FileReaderNode and PerformanceReportNode, for 77 total.
 
 ## 사용 예시
 

{programgarden_core-1.31.1 → programgarden_core-2.1.0}/README.md

@@ -43,7 +43,7 @@ poetry add programgarden-core
 | analysis | 2 | BacktestEngineNode, BenchmarkCompareNode |
 | ai | 2 | LLMModelNode, AIAgentNode |
 
-> Community adds five nodes: TelegramNode, FearGreedIndexNode, FundamentalDataNode, FileReaderNode and PerformanceReportNode, for 78 total.
+> Community adds four nodes: TelegramNode, FearGreedIndexNode, FileReaderNode and PerformanceReportNode, for 77 total.
 
 ## 사용 예시
 

{programgarden_core-1.31.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-1.31.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
@@ -149,6 +151,21 @@ class DateNamespace:
         'iso': '%Y-%m-%d',
     }
 
+    def __init__(self, *, as_of: Optional[str] = None):
+        """Optionally pin replay helpers to an explicit timezone-aware instant.
+
+        Live callers omit as_of and retain their existing local-clock behavior.
+        The execution host, never a model-supplied node setting, owns this clock.
+        """
+        self._as_of = None
+        if as_of is not None:
+            self._as_of = datetime.fromisoformat(as_of.replace("Z", "+00:00"))
+            if self._as_of.tzinfo is None or self._as_of.utcoffset() is None:
+                raise ValueError("Replay as_of must include its timezone")
+
+    def _today(self) -> date:
+        return self._as_of.date() if self._as_of is not None else date.today()
+
     def _format_date(self, d: date, fmt: Optional[str] = None) -> str:
         """날짜를 지정된 포맷으로 변환"""
         if fmt is None:
@@ -159,40 +176,40 @@ class DateNamespace:
 
     def today(self, format: Optional[str] = None) -> str:
         """오늘 날짜"""
-        return self._format_date(date.today(), format)
+        return self._format_date(self._today(), format)
 
     def now(self) -> str:
         """현재 시간 (ISO 형식)"""
-        return datetime.now().isoformat()[:19]
+        return self._as_of.isoformat(timespec="seconds") if self._as_of is not None else datetime.now().isoformat()[:19]
 
     def ago(self, days: int, format: Optional[str] = None) -> str:
         """n일 전"""
-        d = date.today() - timedelta(days=int(days))
+        d = self._today() - timedelta(days=int(days))
         return self._format_date(d, format)
 
     def later(self, days: int, format: Optional[str] = None) -> str:
         """n일 후"""
-        d = date.today() + timedelta(days=int(days))
+        d = self._today() + timedelta(days=int(days))
         return self._format_date(d, format)
 
     def months_ago(self, months: int, format: Optional[str] = None) -> str:
         """n개월 전 (30일 기준)"""
-        d = date.today() - timedelta(days=int(months) * 30)
+        d = self._today() - timedelta(days=int(months) * 30)
         return self._format_date(d, format)
 
     def year_start(self, format: Optional[str] = None) -> str:
         """연초 (1월 1일)"""
-        d = date(date.today().year, 1, 1)
+        d = date(self._today().year, 1, 1)
         return self._format_date(d, format)
 
     def year_end(self, format: Optional[str] = None) -> str:
         """연말 (12월 31일)"""
-        d = date(date.today().year, 12, 31)
+        d = date(self._today().year, 12, 31)
         return self._format_date(d, format)
 
     def month_start(self, format: Optional[str] = None) -> str:
         """월초"""
-        d = date.today().replace(day=1)
+        d = self._today().replace(day=1)
         return self._format_date(d, format)
 
 
@@ -926,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"])
@@ -937,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-1.31.1 → programgarden_core-2.1.0}/programgarden_core/i18n/locales/en.json

@@ -64,8 +64,6 @@
   "nodes.EventHandlerNode.name": "Event Handler",
   "nodes.FearGreedIndexNode.description": "Fetches the CNN Fear & Greed Index, a market sentiment indicator ranging from 0 (Extreme Fear) to 100 (Extreme Greed). No broker connection or API key required. Outputs the current index value (0-100), label (Extreme Fear / Fear / Neutral / Greed / Extreme Greed), and previous day's close value. Built-in resilience with retry on API failures. Typical connection: FearGreedIndexNode → ConditionNode (for sentiment-based trading signals) or → SummaryDisplayNode.",
   "nodes.FearGreedIndexNode.name": "Fear & Greed Index",
-  "nodes.FundamentalDataNode.description": "Fetches company financial data via Financial Modeling Prep (FMP) API. Supports four data types: company profile, income statement, balance sheet, and key metrics. Configure period (annual/quarter) and limit (number of periods to fetch). Requires FMP API credentials. Outputs financial data array and query summary. Typical connection: WatchlistNode → FundamentalDataNode → ConditionNode (for fundamental screening) or → TableDisplayNode.",
-  "nodes.FundamentalDataNode.name": "Fundamental Data (FMP)",
   "nodes.PerformanceReportNode.name": "Performance Report (quantstats)",
   "nodes.PerformanceReportNode.description": "Computes risk/return metrics (Sharpe, Sortino, max drawdown, CAGR, annualized volatility, Calmar) from an equity curve, price series, or return series using quantstats. Optionally computes beta and alpha against a benchmark series. Emits a drawdown time series and a formatted text report, and runs headless via the matplotlib Agg backend. Requires the optional 'perf' extra (pip install 'programgarden-community[perf]'); a missing or partially-installed extra raises a structured MissingDependencyError. Typical connection: BacktestEngineNode → PerformanceReportNode → TableDisplayNode.",
   "nodes.FieldMappingNode.description": "Renames field names in data objects to a standard format. Use to normalize external API responses so downstream nodes can access data with consistent field names (e.g., rename 'adj_close' to 'close', 'vol' to 'volume'). Configure mappings as from/to pairs. Outputs mapped_data with renamed fields. Set preserve_unmapped=true to keep original fields alongside renamed ones. Note: this node only renames fields — it does not generate or transform data values. Typical connection: HTTPRequestNode → FieldMappingNode → ConditionNode.",
@@ -293,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.",
@@ -318,13 +316,6 @@
   "fields.FileReaderNode.max_file_size_mb": "Maximum file size per file (MB). Range 1-50, default 10MB.",
   "fields.FearGreedIndexNode.resilience": "Retry and fallback settings for API call failures",
   "fields.FearGreedIndexNode.timeout_seconds": "API request timeout (seconds). Default 30s, adjust based on your network conditions.",
-  "fields.FundamentalDataNode.credential_id": "FMP API key issued by financialmodelingprep.com. Select, replace or unlink its credential in node details. You can save an unlinked draft and run offline fixture checks; live data remains unverified until you connect a valid key with access to the selected endpoint.",
-  "fields.FundamentalDataNode.symbols": "Symbols to query. [{symbol, exchange}] format.",
-  "fields.FundamentalDataNode.data_type": "Data type: profile, income_statement, balance_sheet, key_metrics",
-  "fields.FundamentalDataNode.period": "Period: annual or quarter. Used for financial statements and key metrics.",
-  "fields.FundamentalDataNode.limit": "Number of periods to fetch (most recent N). Default 1.",
-  "fields.FundamentalDataNode.timeout_seconds": "API request timeout (seconds). Default 30s.",
-  "fields.FundamentalDataNode.resilience": "Retry and fallback settings for API call failures",
   "fields.PerformanceReportNode.data": "Input series: an array of numbers or of {date, <value_field>} objects (equity curve, price levels, or periodic returns).",
   "fields.PerformanceReportNode.data_kind": "Kind of the input series: 'equity', 'prices', or 'returns'. Level series ('equity'/'prices') are converted to returns internally.",
   "fields.PerformanceReportNode.value_field": "Key holding the numeric value when rows are objects (default 'close'; falls back to value/equity/return).",
@@ -655,13 +646,6 @@
   "fieldNames.FileReaderNode.max_file_size_mb": "Max Size (MB)",
   "fieldNames.FearGreedIndexNode.resilience": "Resilience",
   "fieldNames.FearGreedIndexNode.timeout_seconds": "Timeout (sec)",
-  "fieldNames.FundamentalDataNode.credential_id": "FMP Credential",
-  "fieldNames.FundamentalDataNode.symbols": "Symbols",
-  "fieldNames.FundamentalDataNode.data_type": "Data Type",
-  "fieldNames.FundamentalDataNode.period": "Period",
-  "fieldNames.FundamentalDataNode.limit": "Limit",
-  "fieldNames.FundamentalDataNode.timeout_seconds": "Timeout (sec)",
-  "fieldNames.FundamentalDataNode.resilience": "Resilience",
   "fieldNames.PerformanceReportNode.data": "Data Series",
   "fieldNames.PerformanceReportNode.data_kind": "Data Kind",
   "fieldNames.PerformanceReportNode.value_field": "Value Field",
@@ -886,8 +870,6 @@
   "outputs.FearGreedIndexNode.label": "Index label (Extreme Fear / Fear / Neutral / Greed / Extreme Greed)",
   "outputs.FearGreedIndexNode.previous_close": "Previous day's Fear & Greed Index value",
   "outputs.FearGreedIndexNode.value": "Fear & Greed Index (0~100)",
-  "outputs.FundamentalDataNode.data": "Financial data array [{symbol, exchange, ...}]",
-  "outputs.FundamentalDataNode.summary": "Query summary {data_type, symbol_count, record_count}",
   "outputs.PerformanceReportNode.metrics": "Metrics object {sharpe, sortino, max_drawdown, cagr, volatility, calmar[, beta, alpha]} (null on insufficient data).",
   "outputs.PerformanceReportNode.report": "Formatted multi-line performance report text.",
   "outputs.PerformanceReportNode.drawdown_series": "Drawdown time series as an array of {date, drawdown}.",

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

@@ -68,8 +68,6 @@
   "nodes.FileReaderNode.name": "파일 리더",
   "nodes.FearGreedIndexNode.description": "CNN 공포/탐욕 지수를 조회합니다. 0(극단적 공포)부터 100(극단적 탐욕)까지의 시장 심리 지표입니다. 브로커 연결이나 API 키가 필요 없습니다. 출력: 현재 지수값(0-100), 라벨(Extreme Fear / Fear / Neutral / Greed / Extreme Greed), 전일 종가. API 오류 시 자동 재시도 기능 내장. 일반적인 연결: FearGreedIndexNode → ConditionNode (심리 기반 매매 시그널) 또는 → SummaryDisplayNode.",
   "nodes.FearGreedIndexNode.name": "공포/탐욕 지수",
-  "nodes.FundamentalDataNode.description": "Financial Modeling Prep (FMP) API로 기업 재무 데이터를 조회합니다. 4가지 데이터 유형: 기업 프로필, 손익계산서, 대차대조표, 핵심 지표. 기간(연간/분기)과 조회 수(최근 N기)를 설정합니다. FMP API 인증 정보 필요. 출력: 재무 데이터 배열, 조회 요약. 일반적인 연결: WatchlistNode → FundamentalDataNode → ConditionNode (펀더멘털 스크리닝) 또는 → TableDisplayNode.",
-  "nodes.FundamentalDataNode.name": "재무 데이터 (FMP)",
   "nodes.PerformanceReportNode.name": "성과 리포트 (quantstats)",
   "nodes.PerformanceReportNode.description": "자산곡선(equity)·가격·수익률 시계열로부터 quantstats 로 리스크·수익 지표(Sharpe, Sortino, 최대낙폭, CAGR, 연율 변동성, Calmar)를 산출합니다. 벤치마크 시계열을 지정하면 beta/alpha 를 추가로 계산합니다. 낙폭 시계열과 서식 리포트 텍스트를 출력하며, matplotlib Agg 백엔드로 헤드리스 동작합니다. 선택 'perf' extra 필요(pip install 'programgarden-community[perf]') — 미설치/부분설치 시 구조화된 MissingDependencyError 를 발생시킵니다. 대표 연결: BacktestEngineNode → PerformanceReportNode → TableDisplayNode.",
   "nodes.HTTPRequestNode.description": "GET, POST, PUT, PATCH, DELETE를 지원하는 외부 REST API 호출 노드입니다. URL({{ }} 표현식 지원), 헤더, 쿼리 파라미터, JSON 요청 본문을 설정합니다. 인증 방식: Bearer 토큰, 헤더 키, 기본 인증, 쿼리 파라미터. 서버 에러(5xx), 속도 제한(429), 네트워크 장애 시 자동 재시도 기능 내장. 출력: 응답 데이터, HTTP 상태 코드, 응답 헤더, 응답 시간(ms). 실시간 데이터 소스 연결 시 ThrottleNode 필수. 일반적인 연결: ThrottleNode → HTTPRequestNode → FieldMappingNode. AI Agent 도구로 사용 가능.",
@@ -293,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 응답이나 다른 노드 출력을 바인딩하세요.",
@@ -318,13 +316,6 @@
   "fields.FileReaderNode.max_file_size_mb": "파일당 최대 크기 (MB). 1~50, 기본 10MB.",
   "fields.FearGreedIndexNode.resilience": "API 호출 실패 시 재시도 및 폴백 설정",
   "fields.FearGreedIndexNode.timeout_seconds": "API 요청 타임아웃 (초). 기본 30초, 네트워크 환경에 따라 조정하세요.",
-  "fields.FundamentalDataNode.credential_id": "financialmodelingprep.com에서 발급받은 FMP API 키를 등록하고 선택하세요. 노드 상세정보에서 교체·연결 해제가 가능합니다. 키 없이 초안 저장과 샘플 데이터 검증은 가능하지만, 실제 데이터 조회는 해당 자료의 이용권한이 있는 키를 연결한 뒤 확인해야 합니다.",
-  "fields.FundamentalDataNode.symbols": "조회할 종목 목록. [{symbol, exchange}] 형식.",
-  "fields.FundamentalDataNode.data_type": "데이터 유형: profile(기업정보), income_statement(손익계산서), balance_sheet(대차대조표), key_metrics(핵심지표)",
-  "fields.FundamentalDataNode.period": "기간: annual(연간), quarter(분기). 재무제표/핵심지표 조회 시 사용.",
-  "fields.FundamentalDataNode.limit": "가져올 기간 수 (최근 N개). 기본 1.",
-  "fields.FundamentalDataNode.timeout_seconds": "API 요청 타임아웃 (초). 기본 30초.",
-  "fields.FundamentalDataNode.resilience": "API 호출 실패 시 재시도 및 폴백 설정",
   "fields.PerformanceReportNode.data": "입력 시계열: 숫자 배열 또는 {date, <value_field>} 객체 배열(자산곡선/가격/수익률).",
   "fields.PerformanceReportNode.data_kind": "입력 종류: 'equity'/'prices'/'returns'. 레벨 시계열('equity'/'prices')은 내부에서 수익률로 변환됩니다.",
   "fields.PerformanceReportNode.value_field": "행이 객체일 때 숫자 값을 담은 키(기본 'close'; value/equity/return 폴백).",
@@ -655,13 +646,6 @@
   "fieldNames.FileReaderNode.max_file_size_mb": "최대크기(MB)",
   "fieldNames.FearGreedIndexNode.resilience": "재시도설정",
   "fieldNames.FearGreedIndexNode.timeout_seconds": "타임아웃(초)",
-  "fieldNames.FundamentalDataNode.credential_id": "FMP 인증",
-  "fieldNames.FundamentalDataNode.symbols": "종목",
-  "fieldNames.FundamentalDataNode.data_type": "데이터유형",
-  "fieldNames.FundamentalDataNode.period": "기간",
-  "fieldNames.FundamentalDataNode.limit": "조회수",
-  "fieldNames.FundamentalDataNode.timeout_seconds": "타임아웃(초)",
-  "fieldNames.FundamentalDataNode.resilience": "재시도설정",
   "fieldNames.PerformanceReportNode.data": "데이터 시계열",
   "fieldNames.PerformanceReportNode.data_kind": "데이터 종류",
   "fieldNames.PerformanceReportNode.value_field": "값 필드",
@@ -886,8 +870,6 @@
   "outputs.FearGreedIndexNode.label": "지수 라벨 (Extreme Fear / Fear / Neutral / Greed / Extreme Greed)",
   "outputs.FearGreedIndexNode.previous_close": "전일 공포/탐욕 지수",
   "outputs.FearGreedIndexNode.value": "공포/탐욕 지수 (0~100)",
-  "outputs.FundamentalDataNode.data": "재무 데이터 배열 [{symbol, exchange, ...}]",
-  "outputs.FundamentalDataNode.summary": "조회 요약 {data_type, symbol_count, record_count}",
   "outputs.PerformanceReportNode.metrics": "지표 객체 {sharpe, sortino, max_drawdown, cagr, volatility, calmar[, beta, alpha]} (데이터 부족 시 null).",
   "outputs.PerformanceReportNode.report": "서식 성과 리포트 텍스트.",
   "outputs.PerformanceReportNode.drawdown_series": "낙폭 시계열 [{date, drawdown}] 배열.",

{programgarden_core-1.31.1 → programgarden_core-2.1.0}/programgarden_core/models/credential.py

@@ -91,16 +91,6 @@ class Credential(BaseModel):
 # Built-in credential type schemas
 # 디자인(레이아웃, 간격, 스타일) 요소는 포함하지 않음 - 클라이언트 개발자가 직접 구현
 BUILTIN_CREDENTIAL_SCHEMAS: Dict[str, CredentialTypeSchema] = {
-    "fmp_api": CredentialTypeSchema(
-        type_id="fmp_api",
-        name="FMP 재무 데이터 API",
-        description="증권사 계좌와 별도로 등록하는 Financial Modeling Prep 재무 데이터 API 키",
-        widget_schema={"fields": [
-            {"key": "name", "type": "text", "label": "인증정보 이름", "required": True},
-            {"key": "api_key", "type": "password", "label": "FMP API 키", "required": True,
-             "description": "https://site.financialmodelingprep.com/developer/docs/dashboard 에서 발급"},
-        ]},
-    ),
     # ============================================================
     # LS증권 해외주식 (overseas_stock) - 모의투자 미지원
     # ============================================================

{programgarden_core-1.31.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-1.31.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-1.31.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-1.31.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-1.31.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-1.31.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-1.31.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-1.31.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-1.31.1 → programgarden_core-2.1.0}/programgarden_core/nodes/fundamental_stock.py

@@ -64,7 +64,7 @@ class OverseasStockFundamentalNode(BaseNode):
 
     _usage: ClassVar[Dict[str, Any]] = {
         "when_to_use": [
-            "Retrieve fundamental valuation data (PER, EPS, PBR, market cap, 52w high/low, sector) for a US-listed stock",
+            "Retrieve LS security-detail data (PER, EPS, market cap, 52w high/low, industry) for a US-listed stock using the existing broker connection",
             "Screen or rank stocks by fundamental criteria — pair with ConditionNode or FieldMappingNode for filtering",
             "Give an AI Agent context about a stock's valuation alongside price data for investment thesis generation",
         ],
@@ -72,6 +72,7 @@ class OverseasStockFundamentalNode(BaseNode):
             "For Korean domestic stock fundamentals — use KoreaStockFundamentalNode",
             "When you only need price/volume data — use OverseasStockMarketDataNode",
             "For real-time earnings or news events — fundamental data is updated daily, not tick-by-tick",
+            "For financial-statement history, free cash flow, ROE or PBR — these are not returned by this node; use a separately verified data source",
         ],
         "typical_scenarios": [
             "SplitNode.item → OverseasStockFundamentalNode → ConditionNode (filter by PER < 20)",
@@ -80,7 +81,8 @@ class OverseasStockFundamentalNode(BaseNode):
         ],
     }
     _features: ClassVar[List[str]] = [
-        "Returns per, pbr, eps, market_cap, shares_outstanding, 52w_high, 52w_low, sector, industry fields",
+        "Returns per, eps, market_cap, shares_outstanding, high_52w, low_52w and industry fields",
+        "Uses the LS overseas-stock broker credential; no separate financial-data subscription key is required",
         "Item-based execution: pair with SplitNode to fetch fundamentals for each symbol in a universe",
         "is_tool_enabled=True — AI Agent can call this node to analyze stock valuation autonomously",
         "Broker connection is auto-injected via DAG traversal from OverseasStockBrokerNode",
@@ -130,7 +132,7 @@ class OverseasStockFundamentalNode(BaseNode):
                     }
                 ],
             },
-            "expected_output": "value port: {symbol, exchange, per, pbr, eps, market_cap, shares_outstanding, 52w_high, 52w_low, sector, industry}.",
+            "expected_output": "value port: {symbol, exchange, per, eps, market_cap, shares_outstanding, high_52w, low_52w, industry}.",
         },
         {
             "title": "Fundamental screening — filter low-PER stocks",
@@ -172,7 +174,7 @@ class OverseasStockFundamentalNode(BaseNode):
             "Supported exchanges: NYSE, NASDAQ, AMEX. Broker connection is auto-injected."
         ),
         "output_consumption": (
-            "The `value` port emits: {symbol, exchange, per, pbr, eps, market_cap, shares_outstanding, 52w_high, 52w_low, sector, industry}. "
+            "The `value` port emits: {symbol, exchange, per, eps, market_cap, shares_outstanding, high_52w, low_52w, industry}. "
             "Access individual fields via `{{ nodes.fundamental.value.per }}`."
         ),
         "common_combinations": [
@@ -182,7 +184,8 @@ class OverseasStockFundamentalNode(BaseNode):
         ],
         "pitfalls": [
             "Fundamental data is updated daily — do not use it as a real-time signal",
-            "PER may be null for pre-earnings or non-profitable companies — add null-check in ConditionNode logic",
+            "Missing broker fields can be empty or zero. For a positive-PER screen require a finite numeric per > 0 before comparing the upper bound; missing/zero/negative data must not create a buy signal",
+            "LS does not document the PER computation basis or the market-cap currency unit here. Do not claim TTM equivalence or compare cross-provider values without confirming the contract",
             "The symbol field expects a single dict; use SplitNode for multi-symbol fundamental queries",
         ],
     }

{programgarden_core-1.31.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-1.31.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-1.31.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-1.31.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-1.31.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-1.31.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 = "1.31.1"
+version = "2.1.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의"
 readme = "README.md"
@@ -16,7 +16,7 @@ packages = [
 ]
 
 [tool.poetry.dependencies]
-pydantic = ">=2.0.0,<3.0.0"
+pydantic = ">=2.0.1,<3.0.0"
 tzdata = "^2025.2"
 
 [tool.poetry.group.dev.dependencies]
@@ -26,5 +26,5 @@ mypy = "^1.0.0"
 ruff = "^0.1.0"
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
+requires = ["poetry-core>=2.0.1,<3.0.0"]
 build-backend = "poetry.core.masonry.api"