cnhkmcp 2.3.7__py3-none-any.whl → 2.3.8__py3-none-any.whl

cnhkmcp/untracked/APP/trailSomeAlphas/skills/brain-feature-implementation/scripts/validator.py

@@ -613,6 +613,16 @@ class ExpressionValidator:
         """验证参数类型是否符合预期"""
         errors = []
 
+        def _is_number_like(node: ASTNode) -> bool:
+            if node is None:
+                return False
+            if node.node_type == 'number':
+                return True
+            if node.node_type == 'unop' and isinstance(node.value, dict) and node.value.get('op') in {'-', '+'}:
+                if node.children and hasattr(node.children[0], 'node_type'):
+                    return _is_number_like(node.children[0])
+            return False
+
         # Unit compatibility check
         # bucket()/group_cartesian_product() output a derived category (grouping key).
         # It can only be consumed where a category/grouping key is expected (typically by group_* operators).
@@ -634,7 +644,8 @@ class ExpressionValidator:
             # 表达式可以是任何有效的AST节点
             pass
         elif expected_type == 'number':
-            if arg.node_type != 'number':
+            # 允许 -1 这类一元负号数字常量（解析为 unop(number)）
+            if not _is_number_like(arg):
                 errors.append(f"参数 {arg_index+1} 应该是一个数字，但得到 {arg.node_type}")
         elif expected_type == 'boolean':
             # 布尔值可以是 true/false 或数字（0/1）
@@ -901,6 +912,173 @@ class ExpressionValidator:
         Returns:
             Tuple[bool, str]: (是否成功, 转换后的表达式或错误信息)
         """
+        def _top_level_equals_positions(stmt: str) -> List[int]:
+            """返回所有“顶层赋值”等号位置。
+
+            仅统计括号外（()[]{})、引号外、且不属于比较操作符(==,!=,<=,>=)的 '='。
+            这样可以避免把关键字参数（如 rettype=0）误判为赋值语句。
+            """
+            positions: List[int] = []
+            paren_depth = 0
+            bracket_depth = 0
+            brace_depth = 0
+            in_single_quote = False
+            in_double_quote = False
+            escape = False
+
+            for i, ch in enumerate(stmt):
+                if escape:
+                    escape = False
+                    continue
+                if ch == '\\':
+                    escape = True
+                    continue
+
+                if in_single_quote:
+                    if ch == "'":
+                        in_single_quote = False
+                    continue
+                if in_double_quote:
+                    if ch == '"':
+                        in_double_quote = False
+                    continue
+
+                if ch == "'":
+                    in_single_quote = True
+                    continue
+                if ch == '"':
+                    in_double_quote = True
+                    continue
+
+                if ch == '(':
+                    paren_depth += 1
+                    continue
+                if ch == ')':
+                    paren_depth = max(0, paren_depth - 1)
+                    continue
+                if ch == '[':
+                    bracket_depth += 1
+                    continue
+                if ch == ']':
+                    bracket_depth = max(0, bracket_depth - 1)
+                    continue
+                if ch == '{':
+                    brace_depth += 1
+                    continue
+                if ch == '}':
+                    brace_depth = max(0, brace_depth - 1)
+                    continue
+
+                if paren_depth or bracket_depth or brace_depth:
+                    continue
+
+                if ch != '=':
+                    continue
+
+                # 过滤比较操作符(==,!=,<=,>=)
+                prev_ch = stmt[i - 1] if i > 0 else ''
+                next_ch = stmt[i + 1] if i + 1 < len(stmt) else ''
+                if prev_ch in ['=', '!', '<', '>'] or next_ch == '=':
+                    continue
+
+                positions.append(i)
+
+            return positions
+
+        def _keyword_arg_names(stmt: str):
+            """提取函数调用中的命名参数名（如 rettype=0 中的 rettype）。
+
+            只收集括号/中括号/大括号内部出现的 name= 形式，避免把脚本级赋值误当作命名参数。
+            """
+            names = set()
+            paren_depth = 0
+            bracket_depth = 0
+            brace_depth = 0
+            in_single_quote = False
+            in_double_quote = False
+            escape = False
+
+            i = 0
+            while i < len(stmt):
+                ch = stmt[i]
+
+                if escape:
+                    escape = False
+                    i += 1
+                    continue
+                if ch == '\\':
+                    escape = True
+                    i += 1
+                    continue
+
+                if in_single_quote:
+                    if ch == "'":
+                        in_single_quote = False
+                    i += 1
+                    continue
+                if in_double_quote:
+                    if ch == '"':
+                        in_double_quote = False
+                    i += 1
+                    continue
+
+                if ch == "'":
+                    in_single_quote = True
+                    i += 1
+                    continue
+                if ch == '"':
+                    in_double_quote = True
+                    i += 1
+                    continue
+
+                if ch == '(':
+                    paren_depth += 1
+                    i += 1
+                    continue
+                if ch == ')':
+                    paren_depth = max(0, paren_depth - 1)
+                    i += 1
+                    continue
+                if ch == '[':
+                    bracket_depth += 1
+                    i += 1
+                    continue
+                if ch == ']':
+                    bracket_depth = max(0, bracket_depth - 1)
+                    i += 1
+                    continue
+                if ch == '{':
+                    brace_depth += 1
+                    i += 1
+                    continue
+                if ch == '}':
+                    brace_depth = max(0, brace_depth - 1)
+                    i += 1
+                    continue
+
+                inside_container = bool(paren_depth or bracket_depth or brace_depth)
+
+                if inside_container and (ch.isalpha() or ch == '_'):
+                    start = i
+                    i += 1
+                    while i < len(stmt) and (stmt[i].isalnum() or stmt[i] == '_'):
+                        i += 1
+                    name = stmt[start:i]
+
+                    j = i
+                    while j < len(stmt) and stmt[j].isspace():
+                        j += 1
+
+                    if j < len(stmt) and stmt[j] == '=':
+                        next_ch = stmt[j + 1] if j + 1 < len(stmt) else ''
+                        if next_ch != '=':
+                            names.add(name.lower())
+                    continue
+
+                i += 1
+
+            return names
+
         # 检查表达式是否以分号结尾
         if expression.strip().endswith(';'):
             return False, "表达式不能以分号结尾"
@@ -915,51 +1093,13 @@ class ExpressionValidator:
         
         # 处理每个赋值语句（除了最后一个）
         for i, stmt in enumerate(statements[:-1]):
-            # 检查是否包含赋值符号
-            if '=' not in stmt:
-                return False, f"第{i+1}个语句必须是赋值语句（使用=符号）"
-            
-            # 检查是否是比较操作符（==, !=, <=, >=）
-            if any(op in stmt for op in ['==', '!=', '<=', '>=']):
-                # 如果包含比较操作符，需要确认是否有赋值符号
-                # 使用临时替换法：将比较操作符替换为临时标记，再检查是否还有=
-                temp_stmt = stmt
-                for op in ['==', '!=', '<=', '>=']:
-                    temp_stmt = temp_stmt.replace(op, '---')
-                
-                if '=' not in temp_stmt:
-                    return False, f"第{i+1}个语句必须是赋值语句，不能只是比较表达式"
-            
-            # 找到第一个=符号（不是比较操作符的一部分）
-            # 先将比较操作符替换为临时标记，再找=
-            temp_stmt = stmt
-            for op in ['==', '!=', '<=', '>=']:
-                temp_stmt = temp_stmt.replace(op, '---')
-            
-            if '=' not in temp_stmt:
+            eq_positions = _top_level_equals_positions(stmt)
+            if not eq_positions:
                 return False, f"第{i+1}个语句必须是赋值语句（使用=符号）"
-            
-            # 找到实际的=位置
-            equals_pos = temp_stmt.index('=')
-            
-            # 在原始语句中找到对应位置
-            real_equals_pos = 0
-            temp_count = 0
-            for char in stmt:
-                if temp_count == equals_pos:
-                    break
-                if char in '!<>':
-                    # 检查是否是比较操作符的一部分
-                    if real_equals_pos + 1 < len(stmt) and stmt[real_equals_pos + 1] == '=':
-                        # 是比较操作符，跳过两个字符
-                        real_equals_pos += 2
-                        temp_count += 3  # 因为替换成了三个字符的---
-                    else:
-                        real_equals_pos += 1
-                        temp_count += 1
-                else:
-                    real_equals_pos += 1
-                    temp_count += 1
+            if len(eq_positions) > 1:
+                return False, f"第{i+1}个语句只能包含一个赋值符号（=）"
+
+            real_equals_pos = eq_positions[0]
             
             # 分割变量名和值
             var_name = stmt[:real_equals_pos].strip()
@@ -976,9 +1116,12 @@ class ExpressionValidator:
             
             # 检查变量值中使用的变量是否已经定义
             # 简单检查：提取所有可能的变量名
+            kw_names = _keyword_arg_names(var_value)
             used_vars = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', var_value)
             for used_var in used_vars:
                 used_var_lower = used_var.lower()
+                if used_var_lower in kw_names:
+                    continue
                 if used_var_lower not in variables:
                     # 检查是否是函数名
                     if used_var not in supported_functions:
@@ -1001,19 +1144,16 @@ class ExpressionValidator:
         final_stmt = statements[-1]
         
         # 检查最后一个语句是否是赋值语句
-        if '=' in final_stmt:
-            # 替换比较操作符为临时标记，然后检查是否还有单独的=
-            temp_stmt = final_stmt
-            for op in ['==', '!=', '<=', '>=']:
-                temp_stmt = temp_stmt.replace(op, '---')
-            
-            if '=' in temp_stmt:
-                return False, "最后一个语句不能是赋值语句"
+        if _top_level_equals_positions(final_stmt):
+            return False, "最后一个语句不能是赋值语句"
         
         # 检查最后一个语句中使用的变量是否已经定义
+        kw_names = _keyword_arg_names(final_stmt)
         used_vars = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', final_stmt)
         for used_var in used_vars:
             used_var_lower = used_var.lower()
+            if used_var_lower in kw_names:
+                continue
             if used_var_lower not in variables:
                 # 检查是否是函数名
                 if used_var not in supported_functions:

cnhkmcp/untracked/skills/alpha-expression-verifier/scripts/validator.py

@@ -613,6 +613,16 @@ class ExpressionValidator:
         """验证参数类型是否符合预期"""
         errors = []
 
+        def _is_number_like(node: ASTNode) -> bool:
+            if node is None:
+                return False
+            if node.node_type == 'number':
+                return True
+            if node.node_type == 'unop' and isinstance(node.value, dict) and node.value.get('op') in {'-', '+'}:
+                if node.children and hasattr(node.children[0], 'node_type'):
+                    return _is_number_like(node.children[0])
+            return False
+
         # Unit compatibility check
         # bucket()/group_cartesian_product() output a derived category (grouping key).
         # It can only be consumed where a category/grouping key is expected.
@@ -633,7 +643,8 @@ class ExpressionValidator:
             # 表达式可以是任何有效的AST节点
             pass
         elif expected_type == 'number':
-            if arg.node_type != 'number':
+            # 允许 -1 这类一元负号数字常量（解析为 unop(number)）
+            if not _is_number_like(arg):
                 errors.append(f"参数 {arg_index+1} 应该是一个数字，但得到 {arg.node_type}")
         elif expected_type == 'boolean':
             # 布尔值可以是 true/false 或数字（0/1）
@@ -894,6 +905,172 @@ class ExpressionValidator:
         Returns:
             Tuple[bool, str]: (是否成功, 转换后的表达式或错误信息)
         """
+        def _top_level_equals_positions(stmt: str) -> List[int]:
+            """返回所有“顶层赋值”等号位置。
+
+            仅统计括号外（()[]{})、引号外、且不属于比较操作符(==,!=,<=,>=)的 '='。
+            这样可以避免把关键字参数（如 rettype=0）误判为赋值语句。
+            """
+            positions: List[int] = []
+            paren_depth = 0
+            bracket_depth = 0
+            brace_depth = 0
+            in_single_quote = False
+            in_double_quote = False
+            escape = False
+
+            for i, ch in enumerate(stmt):
+                if escape:
+                    escape = False
+                    continue
+                if ch == '\\':
+                    escape = True
+                    continue
+
+                if in_single_quote:
+                    if ch == "'":
+                        in_single_quote = False
+                    continue
+                if in_double_quote:
+                    if ch == '"':
+                        in_double_quote = False
+                    continue
+
+                if ch == "'":
+                    in_single_quote = True
+                    continue
+                if ch == '"':
+                    in_double_quote = True
+                    continue
+
+                if ch == '(':
+                    paren_depth += 1
+                    continue
+                if ch == ')':
+                    paren_depth = max(0, paren_depth - 1)
+                    continue
+                if ch == '[':
+                    bracket_depth += 1
+                    continue
+                if ch == ']':
+                    bracket_depth = max(0, bracket_depth - 1)
+                    continue
+                if ch == '{':
+                    brace_depth += 1
+                    continue
+                if ch == '}':
+                    brace_depth = max(0, brace_depth - 1)
+                    continue
+
+                if paren_depth or bracket_depth or brace_depth:
+                    continue
+
+                if ch != '=':
+                    continue
+
+                prev_ch = stmt[i - 1] if i > 0 else ''
+                next_ch = stmt[i + 1] if i + 1 < len(stmt) else ''
+                if prev_ch in ['=', '!', '<', '>'] or next_ch == '=':
+                    continue
+
+                positions.append(i)
+
+            return positions
+
+        def _keyword_arg_names(stmt: str):
+            """提取函数调用中的命名参数名（如 rettype=0 中的 rettype）。
+
+            只收集括号/中括号/大括号内部出现的 name= 形式，避免把脚本级赋值误当作命名参数。
+            """
+            names = set()
+            paren_depth = 0
+            bracket_depth = 0
+            brace_depth = 0
+            in_single_quote = False
+            in_double_quote = False
+            escape = False
+
+            i = 0
+            while i < len(stmt):
+                ch = stmt[i]
+
+                if escape:
+                    escape = False
+                    i += 1
+                    continue
+                if ch == '\\':
+                    escape = True
+                    i += 1
+                    continue
+
+                if in_single_quote:
+                    if ch == "'":
+                        in_single_quote = False
+                    i += 1
+                    continue
+                if in_double_quote:
+                    if ch == '"':
+                        in_double_quote = False
+                    i += 1
+                    continue
+
+                if ch == "'":
+                    in_single_quote = True
+                    i += 1
+                    continue
+                if ch == '"':
+                    in_double_quote = True
+                    i += 1
+                    continue
+
+                if ch == '(':
+                    paren_depth += 1
+                    i += 1
+                    continue
+                if ch == ')':
+                    paren_depth = max(0, paren_depth - 1)
+                    i += 1
+                    continue
+                if ch == '[':
+                    bracket_depth += 1
+                    i += 1
+                    continue
+                if ch == ']':
+                    bracket_depth = max(0, bracket_depth - 1)
+                    i += 1
+                    continue
+                if ch == '{':
+                    brace_depth += 1
+                    i += 1
+                    continue
+                if ch == '}':
+                    brace_depth = max(0, brace_depth - 1)
+                    i += 1
+                    continue
+
+                inside_container = bool(paren_depth or bracket_depth or brace_depth)
+
+                if inside_container and (ch.isalpha() or ch == '_'):
+                    start = i
+                    i += 1
+                    while i < len(stmt) and (stmt[i].isalnum() or stmt[i] == '_'):
+                        i += 1
+                    name = stmt[start:i]
+
+                    j = i
+                    while j < len(stmt) and stmt[j].isspace():
+                        j += 1
+
+                    if j < len(stmt) and stmt[j] == '=':
+                        next_ch = stmt[j + 1] if j + 1 < len(stmt) else ''
+                        if next_ch != '=':
+                            names.add(name.lower())
+                    continue
+
+                i += 1
+
+            return names
+
         # 检查表达式是否以分号结尾
         if expression.strip().endswith(';'):
             return False, "表达式不能以分号结尾"
@@ -908,51 +1085,13 @@ class ExpressionValidator:
         
         # 处理每个赋值语句（除了最后一个）
         for i, stmt in enumerate(statements[:-1]):
-            # 检查是否包含赋值符号
-            if '=' not in stmt:
-                return False, f"第{i+1}个语句必须是赋值语句（使用=符号）"
-            
-            # 检查是否是比较操作符（==, !=, <=, >=）
-            if any(op in stmt for op in ['==', '!=', '<=', '>=']):
-                # 如果包含比较操作符，需要确认是否有赋值符号
-                # 使用临时替换法：将比较操作符替换为临时标记，再检查是否还有=
-                temp_stmt = stmt
-                for op in ['==', '!=', '<=', '>=']:
-                    temp_stmt = temp_stmt.replace(op, '---')
-                
-                if '=' not in temp_stmt:
-                    return False, f"第{i+1}个语句必须是赋值语句，不能只是比较表达式"
-            
-            # 找到第一个=符号（不是比较操作符的一部分）
-            # 先将比较操作符替换为临时标记，再找=
-            temp_stmt = stmt
-            for op in ['==', '!=', '<=', '>=']:
-                temp_stmt = temp_stmt.replace(op, '---')
-            
-            if '=' not in temp_stmt:
+            eq_positions = _top_level_equals_positions(stmt)
+            if not eq_positions:
                 return False, f"第{i+1}个语句必须是赋值语句（使用=符号）"
-            
-            # 找到实际的=位置
-            equals_pos = temp_stmt.index('=')
-            
-            # 在原始语句中找到对应位置
-            real_equals_pos = 0
-            temp_count = 0
-            for char in stmt:
-                if temp_count == equals_pos:
-                    break
-                if char in '!<>':
-                    # 检查是否是比较操作符的一部分
-                    if real_equals_pos + 1 < len(stmt) and stmt[real_equals_pos + 1] == '=':
-                        # 是比较操作符，跳过两个字符
-                        real_equals_pos += 2
-                        temp_count += 3  # 因为替换成了三个字符的---
-                    else:
-                        real_equals_pos += 1
-                        temp_count += 1
-                else:
-                    real_equals_pos += 1
-                    temp_count += 1
+            if len(eq_positions) > 1:
+                return False, f"第{i+1}个语句只能包含一个赋值符号（=）"
+
+            real_equals_pos = eq_positions[0]
             
             # 分割变量名和值
             var_name = stmt[:real_equals_pos].strip()
@@ -969,9 +1108,12 @@ class ExpressionValidator:
             
             # 检查变量值中使用的变量是否已经定义
             # 简单检查：提取所有可能的变量名
+            kw_names = _keyword_arg_names(var_value)
             used_vars = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', var_value)
             for used_var in used_vars:
                 used_var_lower = used_var.lower()
+                if used_var_lower in kw_names:
+                    continue
                 if used_var_lower not in variables:
                     # 检查是否是函数名
                     if used_var not in supported_functions:
@@ -994,19 +1136,16 @@ class ExpressionValidator:
         final_stmt = statements[-1]
         
         # 检查最后一个语句是否是赋值语句
-        if '=' in final_stmt:
-            # 替换比较操作符为临时标记，然后检查是否还有单独的=
-            temp_stmt = final_stmt
-            for op in ['==', '!=', '<=', '>=']:
-                temp_stmt = temp_stmt.replace(op, '---')
-            
-            if '=' in temp_stmt:
-                return False, "最后一个语句不能是赋值语句"
+        if _top_level_equals_positions(final_stmt):
+            return False, "最后一个语句不能是赋值语句"
         
         # 检查最后一个语句中使用的变量是否已经定义
+        kw_names = _keyword_arg_names(final_stmt)
         used_vars = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', final_stmt)
         for used_var in used_vars:
             used_var_lower = used_var.lower()
+            if used_var_lower in kw_names:
+                continue
             if used_var_lower not in variables:
                 # 检查是否是函数名
                 if used_var not in supported_functions: