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

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

@@ -25,7 +25,8 @@ except ImportError:
 supported_functions = {
     # Group 类别函数
     'group_min': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'category']},
-    'group_mean': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'expression']},
+    # group_mean(x, w, group)
+    'group_mean': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'category']},
     'group_median': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'category']},
     'group_max': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'category']},
     'group_rank': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'category']},
@@ -612,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).
@@ -633,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）
@@ -719,19 +731,54 @@ class ExpressionValidator:
             return cached
 
         derived = False
-        if node.node_type == 'function' and node.value in {'bucket', 'group_cartesian_product'}:
-            derived = True
+        if node.node_type == 'function':
+            if node.value in {'bucket', 'group_cartesian_product'}:
+                derived = True
+            else:
+                function_info = supported_functions.get(node.value, {})
+                arg_types = function_info.get('arg_types', [])
+                param_names = function_info.get('param_names', [])
+
+                positional_index = 0
+                for child in node.children:
+                    if isinstance(child, dict):
+                        if child.get('type') == 'named':
+                            name = child.get('name')
+                            value = child.get('value')
+
+                            expected_type = None
+                            if name in param_names:
+                                param_index = param_names.index(name)
+                                if param_index < len(arg_types):
+                                    expected_type = arg_types[param_index]
+
+                            # Do not propagate "derived" through allowed category/grouping-key inputs.
+                            if expected_type == 'category':
+                                continue
+
+                            if self._is_derived_category(value):
+                                derived = True
+                                break
+                        elif child.get('type') == 'positional':
+                            value = child.get('value')
+                            expected_type = arg_types[positional_index] if positional_index < len(arg_types) else None
+
+                            if expected_type != 'category' and self._is_derived_category(value):
+                                derived = True
+                                break
+                            positional_index += 1
+                    else:
+                        expected_type = arg_types[positional_index] if positional_index < len(arg_types) else None
+                        if expected_type != 'category' and self._is_derived_category(child):
+                            derived = True
+                            break
+                        positional_index += 1
         elif node.node_type in {'unop', 'binop'}:
             derived = any(
                 self._is_derived_category(child)
                 for child in node.children
                 if hasattr(child, 'node_type')
             )
-        elif node.node_type == 'function':
-            derived = any(
-                self._is_derived_category(child.get('value')) if isinstance(child, dict) else self._is_derived_category(child)
-                for child in node.children
-            )
 
         self._derived_category_cache[cache_key] = derived
         return derived
@@ -865,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, "表达式不能以分号结尾"
@@ -879,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()
@@ -940,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:
@@ -965,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: