programgarden-core 1.14.4__tar.gz → 1.15.0__tar.gz

{programgarden_core-1.14.4 → programgarden_core-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden-core
-Version: 1.14.4
+Version: 1.15.0
 Summary: ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의
 Author: 프로그램동산
 Author-email: coding@programgarden.com

{programgarden_core-1.14.4 → programgarden_core-1.15.0}/programgarden_core/expression/evaluator.py

@@ -24,7 +24,7 @@ Jinja2 스타일 {{ }} 표현식 평가기
 - 파일/네트워크 접근 차단
 """
 
-from typing import Any, Dict, Optional, List, Set
+from typing import Any, Callable, Dict, Optional, List, Set
 import re
 import ast
 import operator
@@ -1004,28 +1004,82 @@ class ExpressionEvaluator:
 
         return self.EXPRESSION_PATTERN.sub(replace_expr, value)
 
-    def evaluate_fields(self, fields: Dict[str, Any]) -> Dict[str, Any]:
+    def evaluate_fields(
+        self,
+        fields: Dict[str, Any],
+        on_error: Optional[Callable[[str, Exception], None]] = None,
+    ) -> Dict[str, Any]:
         """
         필드 딕셔너리의 모든 값 평가
 
         Args:
             fields: 노드의 fields 딕셔너리
+            on_error: (선택) leaf 표현식 평가 실패 시 호출되는 콜백
+                ``(expression_text, exception)``. 기본값 None.
+
+                - None 이면 leaf 실패 시 **기존대로 예외를 raise** 한다
+                  (정상 runtime/dry_run 동작 불변 — 이 메서드의 default 시맨틱).
+                - 콜백이 주어지면 raise 하지 않고 ``on_error(value, exc)`` 를
+                  호출한 뒤 **원본 leaf 값을 그대로 유지**한다. 이는
+                  ``evaluate_all_bindings`` 와 동일한 leaf 단위(per-leaf)
+                  try/except 시맨틱으로, deep_validate 가 미해결 binding 을
+                  leaf 단위로 수집할 수 있게 한다.
+
+                dict/list 재귀 시 콜백은 그대로 전파된다.
 
         Returns:
             평가된 필드 딕셔너리
         """
         result = {}
         for key, value in fields.items():
-            if isinstance(value, dict):
-                # 중첩 딕셔너리 재귀 처리
-                result[key] = self.evaluate_fields(value)
-            elif isinstance(value, list):
-                # 리스트 내 표현식 처리
-                result[key] = [self.evaluate(item) for item in value]
-            else:
-                result[key] = self.evaluate(value)
+            result[key] = self._evaluate_field_value(value, on_error)
         return result
 
+    def _evaluate_field_value(
+        self,
+        value: Any,
+        on_error: Optional[Callable[[str, Exception], None]],
+    ) -> Any:
+        """evaluate_fields 의 단일 값 평가.
+
+        재귀 깊이는 정상 모드(``on_error is None``)와 deep 모드(콜백 주어짐)에서
+        **동일**하다 — 기존 ``evaluate_fields`` 시맨틱과 100% 일치시킨다:
+
+        - dict 값 → ``evaluate_fields`` 재귀 (콜백 전파)
+        - list 값 → ``[self.evaluate(item) for item in value]`` (각 item 을
+          ``self.evaluate`` 로만 평가; **list 내부 dict/nested list 는 재귀하지
+          않는다** — 기존 동작). deep 모드면 item 단위 on_error try/except 적용.
+        - 그 외(leaf) → ``self.evaluate(value)`` (deep 모드면 leaf 단위 on_error)
+
+        ``on_error`` 가 주어진 경우(deep 모드)에만 평가 실패를 raise 하지 않고
+        콜백을 호출한 뒤 원본 값을 유지한다.
+        """
+        if isinstance(value, dict):
+            # 중첩 딕셔너리 재귀 처리 — 콜백 전파 (기존 동작)
+            return self.evaluate_fields(value, on_error)
+        if isinstance(value, list):
+            # 리스트는 각 item 을 self.evaluate 로만 평가 (기존 동작 — dict 재귀 안 함)
+            return [self._evaluate_leaf(item, on_error) for item in value]
+        # leaf 값
+        return self._evaluate_leaf(value, on_error)
+
+    def _evaluate_leaf(
+        self,
+        value: Any,
+        on_error: Optional[Callable[[str, Exception], None]],
+    ) -> Any:
+        """단일 leaf 값 평가 (dict/list 재귀 없음). deep 모드면 leaf 단위 on_error."""
+        if on_error is None or not self.is_expression(value):
+            # 기존 경로: on_error 없으면 실패 시 raise (동작 불변),
+            # 표현식이 아니면 그대로 반환.
+            return self.evaluate(value)
+        # on_error 모드 + 표현식 leaf: leaf 단위 try/except (evaluate_all_bindings 시맨틱)
+        try:
+            return self.evaluate(value)
+        except Exception as exc:  # noqa: BLE001 - leaf 단위로 사유를 콜백에 전달
+            on_error(value, exc)
+            return value
+
     def _eval_expression(self, expression: str) -> Any:
         """단일 표현식 평가"""
         evaluator = SafeEvaluator(self._context_dict)

{programgarden_core-1.14.4 → programgarden_core-1.15.0}/programgarden_core/models/validation.py

@@ -69,9 +69,24 @@ class ErrorCode(str, Enum):
     DEEP_VALIDATION_FLOW_BROKEN = "DEEP_VALIDATION_FLOW_BROKEN"
     DEEP_VALIDATION_BINDING_UNRESOLVED = "DEEP_VALIDATION_BINDING_UNRESOLVED"
 
+    # Semantic / safety layer (deep_validate configurable rules — R1~R4).
+    # These are intent/safety checks that structure + dry_run + type validation
+    # cannot express; they are OFF by default and opted into per-rule severity by
+    # the caller (e.g. the chatbot save chokepoint). See programgarden.semantic_rules.
+    SEMANTIC_ORDER_QTY_FROM_AI = "SEMANTIC_ORDER_QTY_FROM_AI"                    # R1
+    SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA = "SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA"  # R2
+    SEMANTIC_HARDCODED_ORDER_QTY = "SEMANTIC_HARDCODED_ORDER_QTY"                # R3
+    SEMANTIC_ORDER_IGNORED_FIELD = "SEMANTIC_ORDER_IGNORED_FIELD"               # R4
+
 
 _DEFAULT_SEVERITY: Dict[ErrorCode, ErrorSeverity] = {
     ErrorCode.UNKNOWN_PLUGIN: ErrorSeverity.WARNING,
+    # Semantic layer default severities (when a rule is enabled without an
+    # explicit severity). R1/R2 are blocking anti-patterns; R3/R4 are advisory.
+    ErrorCode.SEMANTIC_ORDER_QTY_FROM_AI: ErrorSeverity.ERROR,
+    ErrorCode.SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA: ErrorSeverity.ERROR,
+    ErrorCode.SEMANTIC_HARDCODED_ORDER_QTY: ErrorSeverity.WARNING,
+    ErrorCode.SEMANTIC_ORDER_IGNORED_FIELD: ErrorSeverity.WARNING,
 }
 
 

{programgarden_core-1.14.4 → programgarden_core-1.15.0}/pyproject.toml

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