cnhkmcp 2.3.4__tar.gz → 2.3.6__tar.gz

{cnhkmcp-2.3.4/cnhkmcp.egg-info → cnhkmcp-2.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cnhkmcp
-Version: 2.3.4
+Version: 2.3.6
 Summary: A comprehensive Model Context Protocol (MCP) server for quantitative trading platform integration
 Home-page: https://github.com/cnhk/cnhkmcp
 Author: CNHK

{cnhkmcp-2.3.4 → cnhkmcp-2.3.6}/cnhkmcp/__init__.py

@@ -50,7 +50,7 @@ from .untracked.forum_functions import (
     read_full_forum_post
 )
 
-__version__ = "2.3.4"
+__version__ = "2.3.6"
 __author__ = "CNHK"
 __email__ = "cnhk@example.com"
 

{cnhkmcp-2.3.4 → cnhkmcp-2.3.6}/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/main.py

@@ -14,9 +14,12 @@ import sys
 
 # try set gbk problem
 try:
-    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
-except Exception as e:
-    print(e)
+    import io
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding='utf-8')
+    elif hasattr(sys.stdout, 'buffer'):
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception:
     pass
 
 # --- Auto-Install Dependencies ---

{cnhkmcp-2.3.4 → cnhkmcp-2.3.6}/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266//351/246/226/346/254/241/350/277/220/350/241/214/346/211/223/345/274/200/346/210/221.py

@@ -18,9 +18,11 @@ import io
 
 # try set gbk problem
 try:
-    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
-except Exception as e:
-    print(e)
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding='utf-8')
+    elif hasattr(sys.stdout, 'buffer'):
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception:
     pass
 
 # 获取脚本所在目录（项目根目录）

{cnhkmcp-2.3.4 → cnhkmcp-2.3.6}/cnhkmcp/untracked/APP/Tranformer/validator.py

@@ -65,51 +65,65 @@ supported_functions = {
     'ts_delay': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_corr': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'ts_zscore': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_returns': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'mode']},
+    'ts_returns': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'mode'], 'keyword_only': True},
     'ts_product': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_backfill': {'min_args': 2, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'string']},
+    # Platform: ts_backfill(x, d)
+    'ts_backfill': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'd']},
     'days_from_last_change': {'min_args': 1, 'max_args': 1, 'arg_types': ['expression']},
     'last_diff_value': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_scale': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
-    'ts_entropy': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number'], 'param_names': ['x', 'd', 'buckets']},
+    # Platform: ts_scale(x, d, constant=0)
+    'ts_scale': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'constant'], 'keyword_only': True},
+    # Platform: ts_entropy(x, d)
+    'ts_entropy': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'd']},
     'ts_step': {'min_args': 1, 'max_args': 1, 'arg_types': ['number']},
     'ts_sum': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_co_kurtosis': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'inst_tvr': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_decay_exp_window': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'factor']},
+    'ts_decay_exp_window': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'factor'], 'keyword_only': True},
     'ts_av_diff': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_kurtosis': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_min_max_diff': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
+    # Platform: ts_min_max_diff(x, d, f=0.5)
+    'ts_min_max_diff': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'f'], 'keyword_only': True},
     'ts_arg_max': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_max': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_min_max_cps': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
-    'ts_rank': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
+    # Platform: ts_min_max_cps(x, d, f=2)
+    'ts_min_max_cps': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'f'], 'keyword_only': True},
+    # Platform: ts_rank(x, d, constant=0)
+    'ts_rank': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'constant'], 'keyword_only': True},
     'ts_ir': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_theilsen': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
-    'hump_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_weighted_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_quantile': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'string']},
+    # Platform: hump_decay(x, p=0)
+    'hump_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'p'], 'keyword_only': True},
+    # Platform: ts_weighted_decay(x, k=0.5)
+    'ts_weighted_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'k'], 'keyword_only': True},
+    # Platform: ts_quantile(x, d, driver="gaussian")
+    'ts_quantile': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'string'], 'param_names': ['x', 'd', 'driver'], 'keyword_only': True},
     'ts_min': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_count_nans': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_covariance': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'ts_co_skewness': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'ts_min_diff': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_decay_linear': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'boolean']},
-    'jump_decay': {'min_args': 2, 'max_args': 5, 'arg_types': ['expression', 'number', 'expression', 'number', 'number'], 'param_names': ['x', 'd', 'stddev', 'sensitivity', 'force']},
-    'ts_moment': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'k']},
+    # Platform: ts_decay_linear(x, d, dense=false)
+    'ts_decay_linear': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'boolean'], 'param_names': ['x', 'd', 'dense'], 'keyword_only': True},
+    # Platform: jump_decay(x, d, sensitivity=0.5, force=0.1)
+    'jump_decay': {'min_args': 2, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'd', 'sensitivity', 'force'], 'keyword_only': True},
+    # Platform: ts_moment(x, d, k=0)
+    'ts_moment': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'k'], 'keyword_only': True},
     'ts_arg_min': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_regression': {'min_args': 3, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number'], 'param_names': ['y', 'x', 'd', 'lag', 'rettype']},
+    'ts_regression': {'min_args': 3, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number'], 'param_names': ['y', 'x', 'd', 'lag', 'rettype'], 'keyword_only': True},
     'ts_skewness': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_max_diff': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'kth_element': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
     'hump': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'hump']},
     'ts_median': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_delta': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_poly_regression': {'min_args': 3, 'max_args': 4, 'arg_types': ['expression', 'expression', 'number', 'number']},
-    'ts_target_tvr_decay': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'lambda_min', 'lambda_max', 'target_tvr']},
-    'ts_target_tvr_delta_limit': {'min_args': 2, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number']},
-    'ts_target_tvr_hump': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number']},
-    'ts_delta_limit': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
+    # Platform: ts_poly_regression(y, x, d, k=1) and k must be keyword if provided
+    'ts_poly_regression': {'min_args': 3, 'max_args': 4, 'arg_types': ['expression', 'expression', 'number', 'number'], 'param_names': ['y', 'x', 'd', 'k'], 'keyword_only': True, 'keyword_only_from': 3},
+    'ts_target_tvr_decay': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'lambda_min', 'lambda_max', 'target_tvr'], 'keyword_only': True},
+    'ts_target_tvr_delta_limit': {'min_args': 2, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number'], 'param_names': ['x', 'y', 'lambda_min', 'lambda_max', 'target_tvr'], 'keyword_only': True},
+    'ts_target_tvr_hump': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'lambda_min', 'lambda_max', 'target_tvr'], 'keyword_only': True},
+    # Platform: ts_delta_limit(x, y, limit_volume=0.1)
+    'ts_delta_limit': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number'], 'param_names': ['x', 'y', 'limit_volume'], 'keyword_only': True},
     
     # Special 类别函数
     'inst_pnl': {'min_args': 1, 'max_args': 1, 'arg_types': ['expression']},
@@ -276,6 +290,10 @@ class ExpressionValidator:
         self.parser = yacc.yacc(module=self, debug=False)
         # 错误信息存储
         self.errors = []
+        # Cache for unit inference (unit/scalar/category)
+        self._unit_cache: Dict[int, str] = {}
+        # Cache for derived category detection (bucket/group_cartesian_product outputs)
+        self._derived_category_cache: Dict[int, bool] = {}
     
     # 词法分析器规则
     tokens = ('FUNCTION', 'FIELD', 'NUMBER', 'LPAREN', 'RPAREN', 
@@ -509,6 +527,12 @@ class ExpressionValidator:
             return self._validate_add(args, is_in_group_arg)
 
         errors = []
+
+        # Keyword-only enforcement for optional parameters.
+        # If enabled, only the required leading arguments can be positional.
+        keyword_only_from = function_info.get('keyword_only_from')
+        if keyword_only_from is None and function_info.get('keyword_only'):
+            keyword_only_from = function_info.get('min_args', 0)
         
         # 检查参数数量
         if len(args) < function_info['min_args']:
@@ -545,12 +569,14 @@ class ExpressionValidator:
                         errors.append(f"函数 {function_name} 不存在参数 '{arg['name']}'")
                 elif arg['type'] == 'positional':
                     # 位置参数（字典形式）
-                    # 对于winsorize函数，第二个参数必须是命名参数
-                    if function_name == 'winsorize' and positional_index == 1:
-                        errors.append(f"函数 {function_name} 的第二个参数必须使用命名参数 'std='")
-                    # 对于ts_moment函数，第三个参数必须是命名参数
-                    elif function_name == 'ts_moment' and positional_index == 2:
-                        errors.append(f"函数 {function_name} 的第三个参数必须使用命名参数 'k='")
+                    if keyword_only_from is not None and positional_index >= keyword_only_from:
+                        param_name = None
+                        if 'param_names' in function_info and positional_index < len(function_info['param_names']):
+                            param_name = function_info['param_names'][positional_index]
+                        if param_name:
+                            errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数 '{param_name}='")
+                        else:
+                            errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数")
                     else:
                         # 验证位置参数的类型
                         if positional_index < len(function_info['arg_types']):
@@ -564,12 +590,14 @@ class ExpressionValidator:
                     positional_index += 1
             else:
                 # 位置参数（直接ASTNode形式）
-                # 对于winsorize函数，第二个参数必须是命名参数
-                if function_name == 'winsorize' and positional_index == 1:
-                    errors.append(f"函数 {function_name} 的第二个参数必须使用命名参数 'std='")
-                # 对于ts_moment函数，第三个参数必须是命名参数
-                elif function_name == 'ts_moment' and positional_index == 2:
-                    errors.append(f"函数 {function_name} 的第三个参数必须使用命名参数 'k='")
+                if keyword_only_from is not None and positional_index >= keyword_only_from:
+                    param_name = None
+                    if 'param_names' in function_info and positional_index < len(function_info['param_names']):
+                        param_name = function_info['param_names'][positional_index]
+                    if param_name:
+                        errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数 '{param_name}='")
+                    else:
+                        errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数")
                 else:
                     # 验证位置参数的类型
                     if positional_index < len(function_info['arg_types']):
@@ -583,6 +611,15 @@ class ExpressionValidator:
     def _validate_arg_type(self, arg: ASTNode, expected_type: str, arg_index: int, function_name: str, is_in_group_arg: bool = False) -> List[str]:
         """验证参数类型是否符合预期"""
         errors = []
+
+        # 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.
+        if self._is_derived_category(arg) and expected_type != 'category':
+            errors.append(
+                f"Incompatible unit for input of \"{function_name}\" at index {arg_index}, expected \"Unit[]\", found \"Unit[Group:1]\""
+            )
+            return errors
         
         # 首先检查是否是group类型字段，如果是则只能用于Group类型函数
         # 但是如果当前函数是group_xxx或在group函数的参数链中，则允许使用
@@ -618,6 +655,83 @@ class ExpressionValidator:
         
         return errors
 
+    def _infer_unit(self, node: ASTNode) -> str:
+        """Infer the Unit kind of an AST node.
+
+        Returns:
+            'unit'     - regular numeric time-series Unit[]
+            'scalar'   - literals (numbers/booleans/strings)
+            'category' - category/grouping keys (industry/sector or derived via bucket/cartesian)
+        """
+        if node is None:
+            return 'unit'
+
+        cache_key = id(node)
+        cached = self._unit_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        unit = 'unit'
+
+        if node.node_type in {'number', 'boolean', 'string'}:
+            unit = 'scalar'
+        elif node.node_type in {'field', 'identifier'}:
+            unit = 'unit'
+        elif node.node_type == 'category':
+            unit = 'category'
+        elif node.node_type in {'unop', 'binop'}:
+            child_units = [self._infer_unit(child) for child in node.children if hasattr(child, 'node_type')]
+            unit = 'category' if 'category' in child_units else 'unit'
+        elif node.node_type == 'function':
+            fname = node.value
+            if fname in {'bucket', 'group_cartesian_product'}:
+                unit = 'category'
+            else:
+                first_arg = None
+                for child in node.children:
+                    if isinstance(child, dict):
+                        if child.get('type') == 'positional':
+                            first_arg = child.get('value')
+                            break
+                    else:
+                        first_arg = child
+                        break
+                if hasattr(first_arg, 'node_type'):
+                    unit = self._infer_unit(first_arg)
+                else:
+                    unit = 'unit'
+
+        self._unit_cache[cache_key] = unit
+        return unit
+
+    def _is_derived_category(self, node: ASTNode) -> bool:
+        """Return True if node is a derived category/grouping key (e.g., bucket/cartesian output)."""
+        if node is None:
+            return False
+
+        cache_key = id(node)
+        cached = self._derived_category_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        derived = False
+        if node.node_type == 'function' and node.value in {'bucket', 'group_cartesian_product'}:
+            derived = True
+        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
+
     def _validate_add(self, args: List[Any], is_in_group_arg: bool = False) -> List[str]:
         """Validate add(x, y, ..., filter=false).
 
@@ -883,6 +997,9 @@ class ExpressionValidator:
         """
         # 重置错误列表
         self.errors = []
+        # Reset unit inference cache for this expression
+        self._unit_cache = {}
+        self._derived_category_cache = {}
         
         try:
             expression = expression.strip()

{cnhkmcp-2.3.4 → cnhkmcp-2.3.6}/cnhkmcp/untracked/APP/ace_lib.py

@@ -17,9 +17,11 @@ import sys
 import io
 # try set gbk problem
 try:
-    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
-except Exception as e:
-    print(e)
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding='utf-8')
+    elif hasattr(sys.stdout, 'buffer'):
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception:
     pass
 from helpful_functions import (
     expand_dict_columns,

cnhkmcp-2.3.6/cnhkmcp/untracked/APP/blueprints/parsetab.py

@@ -0,0 +1,60 @@
+
+# parsetab.py
+# This file is automatically generated. Do not edit.
+# pylint: disable=W,C,R
+_tabversion = '3.10'
+
+_lr_method = 'LALR'
+
+_lr_signature = 'ASSIGN BOOLEAN CATEGORY COMMA DIVIDE EQUAL FIELD FUNCTION GREATER GREATEREQUAL IDENTIFIER LESS LESSEQUAL LPAREN MINUS NOTEQUAL NUMBER PLUS RPAREN STRING TIMESexpression : comparison\n| expression EQUAL comparison\n| expression NOTEQUAL comparison\n| expression GREATER comparison\n| expression LESS comparison\n| expression GREATEREQUAL comparison\n| expression LESSEQUAL comparisoncomparison : term\n| comparison PLUS term\n| comparison MINUS termterm : factor\n| term TIMES factor\n| term DIVIDE factorfactor : NUMBER\n| STRING\n| FIELD\n| CATEGORY\n| IDENTIFIER\n| BOOLEAN\n| MINUS factor\n| LPAREN expression RPAREN\n| function_callfunction_call : FUNCTION LPAREN args RPARENargs : arg_list\n| emptyarg_list : arg\n| arg_list COMMA argarg : expression\n| IDENTIFIER ASSIGN expressionempty :'
+    
+_lr_action_items = {'NUMBER':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,]),'STRING':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,]),'FIELD':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,]),'CATEGORY':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,]),'IDENTIFIER':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[10,10,10,10,10,10,10,10,10,10,10,10,10,44,44,10,]),'BOOLEAN':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,]),'MINUS':([0,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,21,22,23,24,25,27,28,29,30,31,32,33,34,35,36,37,38,44,45,46,47,],[4,22,-8,4,-11,-14,-15,-16,-17,-18,-19,4,-22,4,4,4,4,4,4,4,4,4,4,-20,4,22,22,22,22,22,22,-9,-10,-12,-13,-21,-18,-23,4,4,]),'LPAREN':([0,4,12,14,15,16,17,18,19,20,21,22,23,24,27,46,47,],[12,12,12,27,12,12,12,12,12,12,12,12,12,12,12,12,12,]),'FUNCTION':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,]),'$end':([1,2,3,5,6,7,8,9,10,11,13,25,28,29,30,31,32,33,34,35,36,37,38,45,],[0,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,-23,]),'EQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[15,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,15,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,15,-18,-23,15,]),'NOTEQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[16,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,16,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,16,-18,-23,16,]),'GREATER':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[17,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,17,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,17,-18,-23,17,]),'LESS':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[18,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,18,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,18,-18,-23,18,]),'GREATEREQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[19,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,19,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,19,-18,-23,19,]),'LESSEQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[20,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,20,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,20,-18,-23,20,]),'RPAREN':([2,3,5,6,7,8,9,10,11,13,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,48,49,],[-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,38,-30,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,45,-24,-25,-26,-28,-18,-23,-27,-29,]),'COMMA':([2,3,5,6,7,8,9,10,11,13,25,28,29,30,31,32,33,34,35,36,37,38,40,42,43,44,45,48,49,],[-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,46,-26,-28,-18,-23,-27,-29,]),'PLUS':([2,3,5,6,7,8,9,10,11,13,25,28,29,30,31,32,33,34,35,36,37,38,44,45,],[21,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,21,21,21,21,21,21,-9,-10,-12,-13,-21,-18,-23,]),'TIMES':([3,5,6,7,8,9,10,11,13,25,34,35,36,37,38,44,45,],[23,-11,-14,-15,-16,-17,-18,-19,-22,-20,23,23,-12,-13,-21,-18,-23,]),'DIVIDE':([3,5,6,7,8,9,10,11,13,25,34,35,36,37,38,44,45,],[24,-11,-14,-15,-16,-17,-18,-19,-22,-20,24,24,-12,-13,-21,-18,-23,]),'ASSIGN':([44,],[47,]),}
+
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+   for _x,_y in zip(_v[0],_v[1]):
+      if not _x in _lr_action:  _lr_action[_x] = {}
+      _lr_action[_x][_k] = _y
+del _lr_action_items
+
+_lr_goto_items = {'expression':([0,12,27,46,47,],[1,26,43,43,49,]),'comparison':([0,12,15,16,17,18,19,20,27,46,47,],[2,2,28,29,30,31,32,33,2,2,2,]),'term':([0,12,15,16,17,18,19,20,21,22,27,46,47,],[3,3,3,3,3,3,3,3,34,35,3,3,3,]),'factor':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[5,25,5,5,5,5,5,5,5,5,5,36,37,5,5,5,]),'function_call':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,]),'args':([27,],[39,]),'arg_list':([27,],[40,]),'empty':([27,],[41,]),'arg':([27,46,],[42,48,]),}
+
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+   for _x, _y in zip(_v[0], _v[1]):
+       if not _x in _lr_goto: _lr_goto[_x] = {}
+       _lr_goto[_x][_k] = _y
+del _lr_goto_items
+_lr_productions = [
+  ("S' -> expression","S'",1,None,None,None),
+  ('expression -> comparison','expression',1,'p_expression','validator.py',390),
+  ('expression -> expression EQUAL comparison','expression',3,'p_expression','validator.py',391),
+  ('expression -> expression NOTEQUAL comparison','expression',3,'p_expression','validator.py',392),
+  ('expression -> expression GREATER comparison','expression',3,'p_expression','validator.py',393),
+  ('expression -> expression LESS comparison','expression',3,'p_expression','validator.py',394),
+  ('expression -> expression GREATEREQUAL comparison','expression',3,'p_expression','validator.py',395),
+  ('expression -> expression LESSEQUAL comparison','expression',3,'p_expression','validator.py',396),
+  ('comparison -> term','comparison',1,'p_comparison','validator.py',403),
+  ('comparison -> comparison PLUS term','comparison',3,'p_comparison','validator.py',404),
+  ('comparison -> comparison MINUS term','comparison',3,'p_comparison','validator.py',405),
+  ('term -> factor','term',1,'p_term','validator.py',412),
+  ('term -> term TIMES factor','term',3,'p_term','validator.py',413),
+  ('term -> term DIVIDE factor','term',3,'p_term','validator.py',414),
+  ('factor -> NUMBER','factor',1,'p_factor','validator.py',421),
+  ('factor -> STRING','factor',1,'p_factor','validator.py',422),
+  ('factor -> FIELD','factor',1,'p_factor','validator.py',423),
+  ('factor -> CATEGORY','factor',1,'p_factor','validator.py',424),
+  ('factor -> IDENTIFIER','factor',1,'p_factor','validator.py',425),
+  ('factor -> BOOLEAN','factor',1,'p_factor','validator.py',426),
+  ('factor -> MINUS factor','factor',2,'p_factor','validator.py',427),
+  ('factor -> LPAREN expression RPAREN','factor',3,'p_factor','validator.py',428),
+  ('factor -> function_call','factor',1,'p_factor','validator.py',429),
+  ('function_call -> FUNCTION LPAREN args RPAREN','function_call',4,'p_function_call','validator.py',457),
+  ('args -> arg_list','args',1,'p_args','validator.py',461),
+  ('args -> empty','args',1,'p_args','validator.py',462),
+  ('arg_list -> arg','arg_list',1,'p_arg_list','validator.py',469),
+  ('arg_list -> arg_list COMMA arg','arg_list',3,'p_arg_list','validator.py',470),
+  ('arg -> expression','arg',1,'p_arg','validator.py',477),
+  ('arg -> IDENTIFIER ASSIGN expression','arg',3,'p_arg','validator.py',478),
+  ('empty -> <empty>','empty',0,'p_empty','validator.py',485),
+]