cnhkmcp 2.1.9__py3-none-any.whl → 2.3.0__py3-none-any.whl

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

@@ -0,0 +1,113 @@
+import json
+import os
+import argparse
+import pandas as pd
+from pathlib import Path
+import sys
+
+print("Script started...", flush=True)
+
+# Ensure local imports work by adding the script directory to sys.path
+script_dir = Path(__file__).resolve().parent
+sys.path.append(str(script_dir))
+
+try:
+    import ace_lib
+except ImportError:
+    print("Error: Could not import 'ace_lib'. Make sure it is in the same directory.")
+    sys.exit(1)
+
+def load_config(config_path):
+    try:
+        with open(config_path, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(description="Fetch dataset fields from WorldQuant BRAIN")
+    parser.add_argument("--datasetid", required=True, help="ID of the dataset to fetch (e.g., specific dataset ID)")
+    parser.add_argument("--region", default="USA", help="Region (default: USA)")
+    parser.add_argument("--delay", type=int, default=1, help="Delay (default: 1)")
+    parser.add_argument("--universe", default="TOP3000", help="Universe (default: TOP3000)")
+    parser.add_argument("--instrument-type", default="EQUITY", dest="instrument_type", help="Instrument Type (default: EQUITY)")
+
+    args = parser.parse_args()
+
+    # Determine paths relative to this script
+    # User requested: robust and no absolute paths hardcoded
+    workspace_dir = script_dir.parent
+    config_path = workspace_dir / "config.json"
+    data_dir = workspace_dir / "data"
+
+    # Ensure data directory exists
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load configuration
+    if not config_path.exists():
+        print(f"Error: Config file not found at {config_path}")
+        sys.exit(1)
+
+    config = load_config(config_path)
+    if not config:
+        sys.exit(1)
+
+    # Extract credentials (env override -> config)
+    email = os.environ.get("BRAIN_USERNAME") or os.environ.get("BRAIN_EMAIL")
+    password = os.environ.get("BRAIN_PASSWORD")
+    if not email or not password:
+        creds = config.get("BRAIN_CREDENTIALS", {})
+        email = email or creds.get("email")
+        password = password or creds.get("password")
+
+    if not email or not password:
+        print("Error: BRAIN credentials missing. Set BRAIN_USERNAME/BRAIN_PASSWORD or config.json")
+        sys.exit(1)
+
+    # Override ace_lib.get_credentials to use our config values
+    # ace_lib.start_session() internally calls get_credentials()
+    ace_lib.get_credentials = lambda: (email, password)
+
+    try:
+        print(f"Logging in as {email}...")
+        session = ace_lib.start_session()
+        
+        print(f"Fetching datafields for dataset: {args.datasetid} (Region: {args.region}, Delay: {args.delay})...")
+        
+        # Fetch datafields using the library function
+        df = ace_lib.get_datafields(
+            session, 
+            dataset_id=args.datasetid, 
+            region=args.region, 
+            delay=args.delay,
+            universe=args.universe,
+            instrument_type=args.instrument_type,
+            data_type="ALL",
+        )
+
+        if df is None or df.empty:
+            print("Error: No data found or empty response.")
+            sys.exit(1)
+
+        # Construct a safe filename and folder name
+        safe_dataset_id = "".join([c for c in args.datasetid if c.isalnum() or c in ('-','_')])
+        folder_name = f"{safe_dataset_id}_{args.region}_delay{args.delay}"
+        dataset_folder = data_dir / folder_name
+        dataset_folder.mkdir(parents=True, exist_ok=True)
+
+        filename = f"{folder_name}.csv"
+        output_path = dataset_folder / filename
+
+        print(f"Saving {len(df)} records to {output_path}...")
+        df.to_csv(output_path, index=False)
+        print("Success.")
+
+    except Exception as e:
+        print(f"An error occurred during execution: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,180 @@
+import json
+import os
+from typing import Union
+
+import pandas as pd
+from pandas.io.formats.style import Styler
+
+brain_api_url = os.environ.get("BRAIN_API_URL", "https://api.worldquantbrain.com")
+brain_url = os.environ.get("BRAIN_URL", "https://platform.worldquantbrain.com")
+
+
+def make_clickable_alpha_id(alpha_id: str) -> str:
+    """
+    Create a clickable HTML link for an alpha ID.
+
+    Args:
+        alpha_id (str): The ID of the alpha.
+
+    Returns:
+        str: An HTML string containing a clickable link to the alpha's page on the platform.
+    """
+
+    url = brain_url + "/alpha/"
+    return f'<a href="{url}{alpha_id}">{alpha_id}</a>'
+
+
+def prettify_result(
+    result: list, detailed_tests_view: bool = False, clickable_alpha_id: bool = False
+) -> Union[pd.DataFrame, Styler]:
+    """
+    Combine and format simulation results into a single DataFrame for analysis.
+
+    Args:
+        result (list): A list of dictionaries containing simulation results.
+        detailed_tests_view (bool, optional): If True, include detailed test results. Defaults to False.
+        clickable_alpha_id (bool, optional): If True, make alpha IDs clickable. Defaults to False.
+
+    Returns:
+        pandas.DataFrame or pandas.io.formats.style.Styler: A DataFrame containing formatted results,
+        optionally with clickable alpha IDs.
+    """
+    list_of_is_stats = [result[x]["is_stats"] for x in range(len(result)) if result[x]["is_stats"] is not None]
+    is_stats_df = pd.concat(list_of_is_stats).reset_index(drop=True)
+    is_stats_df = is_stats_df.sort_values("fitness", ascending=False)
+
+    expressions = {
+        result[x]["alpha_id"]: (
+            {
+                "selection": result[x]["simulate_data"]["selection"],
+                "combo": result[x]["simulate_data"]["combo"],
+            }
+            if result[x]["simulate_data"]["type"] == "SUPER"
+            else result[x]["simulate_data"]["regular"]
+        )
+        for x in range(len(result))
+        if result[x]["is_stats"] is not None
+    }
+    expression_df = pd.DataFrame(list(expressions.items()), columns=["alpha_id", "expression"])
+
+    list_of_is_tests = [result[x]["is_tests"] for x in range(len(result)) if result[x]["is_tests"] is not None]
+    is_tests_df = pd.concat(list_of_is_tests, sort=True).reset_index(drop=True)
+    is_tests_df = is_tests_df[is_tests_df["result"] != "WARNING"]
+    if detailed_tests_view:
+        cols = ["limit", "result", "value"]
+        is_tests_df["details"] = is_tests_df[cols].to_dict(orient="records")
+        is_tests_df = is_tests_df.pivot(index="alpha_id", columns="name", values="details").reset_index()
+    else:
+        is_tests_df = is_tests_df.pivot(index="alpha_id", columns="name", values="result").reset_index()
+
+    alpha_stats = pd.merge(is_stats_df, expression_df, on="alpha_id")
+    alpha_stats = pd.merge(alpha_stats, is_tests_df, on="alpha_id")
+    alpha_stats = alpha_stats.drop(columns=alpha_stats.columns[(alpha_stats == "PENDING").any()])
+    alpha_stats.columns = alpha_stats.columns.str.replace("(?<=[a-z])(?=[A-Z])", "_", regex=True).str.lower()
+    if clickable_alpha_id:
+        return alpha_stats.style.format({"alpha_id": lambda x: make_clickable_alpha_id(str(x))})
+    return alpha_stats
+
+
+def concat_pnl(result: list) -> pd.DataFrame:
+    """
+    Combine PnL results from multiple alphas into a single DataFrame.
+
+    Args:
+        result (list): A list of dictionaries containing simulation results with PnL data.
+
+    Returns:
+        pandas.DataFrame: A DataFrame containing combined PnL data for all alphas.
+    """
+    list_of_pnls = [result[x]["pnl"] for x in range(len(result)) if result[x]["pnl"] is not None]
+    pnls_df = pd.concat(list_of_pnls).reset_index()
+
+    return pnls_df
+
+
+def concat_is_tests(result: list) -> pd.DataFrame:
+    """
+    Combine in-sample test results from multiple alphas into a single DataFrame.
+
+    Args:
+        result (list): A list of dictionaries containing simulation results with in-sample test data.
+
+    Returns:
+        pandas.DataFrame: A DataFrame containing combined in-sample test results for all alphas.
+    """
+    is_tests_list = [result[x]["is_tests"] for x in range(len(result)) if result[x]["is_tests"] is not None]
+    is_tests_df = pd.concat(is_tests_list, sort=True).reset_index(drop=True)
+    return is_tests_df
+
+
+def save_simulation_result(result: dict) -> None:
+    """
+    Save the simulation result to a JSON file in the 'simulation_results' folder.
+
+    Args:
+        result (dict): A dictionary containing the simulation result for an alpha.
+    """
+
+    alpha_id = result["id"]
+    region = result["settings"]["region"]
+    folder_path = "simulation_results/"
+    file_path = os.path.join(folder_path, f"{alpha_id}_{region}")
+
+    os.makedirs(folder_path, exist_ok=True)
+
+    with open(file_path, "w", encoding="utf-8") as file:
+        json.dump(result, file)
+
+
+def save_pnl(pnl_df: pd.DataFrame, alpha_id: str, region: str) -> None:
+    """
+    Save the PnL data for an alpha to a CSV file in the 'alphas_pnl' folder.
+
+    Args:
+        pnl_df (pandas.DataFrame): The DataFrame containing PnL data.
+        alpha_id (str): The ID of the alpha.
+        region (str): The region for which the PnL data was generated.
+    """
+
+    folder_path = "alphas_pnl/"
+    file_path = os.path.join(folder_path, f"{alpha_id}_{region}.csv")
+    os.makedirs(folder_path, exist_ok=True)
+
+    pnl_df.to_csv(file_path)
+
+
+def save_yearly_stats(yearly_stats: pd.DataFrame, alpha_id: str, region: str):
+    """
+    Save the yearly statistics for an alpha to a CSV file in the 'yearly_stats' folder.
+
+    Args:
+        yearly_stats (pandas.DataFrame): The DataFrame containing yearly statistics.
+        alpha_id (str): The ID of the alpha.
+        region (str): The region for which the statistics were generated.
+    """
+
+    folder_path = "yearly_stats/"
+    file_path = os.path.join(folder_path, f"{alpha_id}_{region}.csv")
+    os.makedirs(folder_path, exist_ok=True)
+
+    yearly_stats.to_csv(file_path, index=False)
+
+
+def expand_dict_columns(data: pd.DataFrame) -> pd.DataFrame:
+    """
+    Expand dictionary columns in a DataFrame into separate columns.
+
+    Args:
+        data (pandas.DataFrame): The input DataFrame with dictionary columns.
+
+    Returns:
+        pandas.DataFrame: A new DataFrame with expanded columns.
+    """
+    dict_columns = list(filter(lambda x: isinstance(data[x].iloc[0], dict), data.columns))
+    new_columns = pd.concat(
+        [data[col].apply(pd.Series).rename(columns=lambda x: f"{col}_{x}") for col in dict_columns],
+        axis=1,
+    )
+
+    data = pd.concat([data, new_columns], axis=1)
+    return data

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

@@ -0,0 +1,236 @@
+import pandas as pd
+from pathlib import Path
+import argparse
+import sys
+import re
+import json
+import time
+import itertools
+
+
+def _safe_filename_component(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_-]+", "_", str(value)).strip("_")
+
+
+def _parse_dataset_folder_parts(dataset_folder_name: str) -> tuple[str, str, str] | None:
+    """Parse '<datasetId>_<REGION>_delay<DELAY>' into (datasetId, REGION, DELAY).
+
+    Returns None if parsing fails.
+    """
+
+    name = str(dataset_folder_name)
+    marker = "_delay"
+    pos = name.rfind(marker)
+    if pos == -1:
+        return None
+
+    prefix = name[:pos]
+    delay_str = name[pos + len(marker) :]
+    if not delay_str.isdigit():
+        return None
+
+    region_pos = prefix.rfind("_")
+    if region_pos == -1:
+        return None
+
+    dataset_id = prefix[:region_pos]
+    region = prefix[region_pos + 1 :]
+    if not dataset_id or not region:
+        return None
+
+    return dataset_id, region, delay_str
+
+def load_data(dataset_name=None):
+    script_dir = Path(__file__).resolve().parent
+    workspace_dir = script_dir.parent
+    
+    if not dataset_name:
+        data_root = workspace_dir / "data"
+        if not data_root.exists():
+            print("Error: Data directory not found.", file=sys.stderr)
+            sys.exit(1)
+            
+        subdirs = [d for d in data_root.iterdir() if d.is_dir()]
+        
+        if len(subdirs) == 1:
+            dataset_name = subdirs[0].name
+            print(f"Auto-detected dataset: {dataset_name}", file=sys.stderr)
+        elif len(subdirs) > 1:
+            print("Error: Multiple datasets found. Please specify --dataset.", file=sys.stderr)
+            print("Available datasets:", file=sys.stderr)
+            for d in subdirs:
+                print(f"  {d.name}", file=sys.stderr)
+            sys.exit(1)
+        else:
+            print("Error: No dataset folders found inside data directory.", file=sys.stderr)
+            sys.exit(1)
+
+    dataset_dir = workspace_dir / "data" / dataset_name
+    data_path = dataset_dir / f"{dataset_name}.csv"
+    
+    print(f"Loading data from {data_path}...", file=sys.stderr)
+    try:
+        df = pd.read_csv(data_path)
+        return df, dataset_dir
+    except FileNotFoundError:
+        print(f"Error: Data file not found at {data_path}. Please run fetch_dataset.py first.", file=sys.stderr)
+        sys.exit(1)
+
+def extract_keys_from_template(template):
+    return re.findall(r'\{([A-Za-z0-9_]+)\}', template)
+
+
+def _matches_metric(field_id: str, metric: str) -> bool:
+    """Return True if field_id is a plausible match for metric.
+
+    For very short metrics, require token-boundary matches to avoid accidental
+    matches (e.g. 'ta' in 'total').
+    """
+
+    fid = str(field_id)
+    m = str(metric)
+    if len(m) <= 3:
+        return re.search(rf"(^|_){re.escape(m)}(_|$)", fid, flags=re.IGNORECASE) is not None
+    return m in fid
+
+
+def _common_prefix_len(a: str, b: str) -> int:
+    n = min(len(a), len(b))
+    i = 0
+    while i < n and a[i] == b[i]:
+        i += 1
+    return i
+
+def match_single_horizon_auto(df, template):
+    """Generate expressions from a template by matching each {variable} to dataset field ids.
+
+    Previous behavior required all variables to share an identical "base prefix".
+    That is often too strict for datasets with mixed naming conventions.
+
+    New behavior:
+    - Build candidate lists per metric.
+    - Iterate over a limited set of primary candidates.
+    - For each primary candidate, pick the closest-looking candidates for other metrics
+      (by common prefix length), but DO NOT require the same base.
+    - Combine candidates (capped) and render expressions.
+    """
+
+    metrics = extract_keys_from_template(template)
+    if not metrics:
+        print("Error: No variables found in template (use {variable} format).", file=sys.stderr)
+        return []
+
+    metrics = sorted(metrics, key=len, reverse=True)
+    primary = metrics[0]
+
+    ids = df["id"].dropna().astype(str).tolist()
+
+    # Build candidates per metric
+    candidates_by_metric: dict[str, list[str]] = {}
+    for m in metrics:
+        cands = [fid for fid in ids if _matches_metric(fid, m)]
+        # de-dup while preserving order
+        seen = set()
+        uniq = []
+        for x in cands:
+            if x not in seen:
+                seen.add(x)
+                uniq.append(x)
+        candidates_by_metric[m] = uniq
+
+    if not candidates_by_metric.get(primary):
+        return []
+    for m in metrics[1:]:
+        if not candidates_by_metric.get(m):
+            return []
+
+    MAX_PRIMARY_CANDIDATES = 30
+    MAX_SECONDARY_CHOICES = 8
+    MAX_EXPRESSIONS = 5000
+
+    results = []
+    seen_expr = set()
+
+    primary_candidates = candidates_by_metric[primary][:MAX_PRIMARY_CANDIDATES]
+    for primary_id in primary_candidates:
+        # For each secondary metric, choose best candidates by similarity to primary_id
+        chosen_by_metric: dict[str, list[str]] = {primary: [primary_id]}
+        for m in metrics[1:]:
+            cands = candidates_by_metric[m]
+            ranked = sorted(cands, key=lambda fid: _common_prefix_len(primary_id, fid), reverse=True)
+            chosen_by_metric[m] = ranked[:MAX_SECONDARY_CHOICES]
+
+        # Combine candidates across metrics
+        metric_order = metrics
+        pools = [chosen_by_metric[m] for m in metric_order]
+        for combo in itertools.product(*pools):
+            field_map = dict(zip(metric_order, combo))
+            try:
+                expr = template.format(**field_map)
+            except Exception:
+                continue
+            if expr in seen_expr:
+                continue
+            seen_expr.add(expr)
+            results.append(("flex", expr))
+            if len(results) >= MAX_EXPRESSIONS:
+                return results
+
+    return results
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate Alpha Expressions based on patterns")
+    parser.add_argument("--template", required=True, help="Python format string (e.g. '{st_dev} / abs({mean})')")
+    parser.add_argument("--dataset", help="Name of the dataset folder. Auto-detected if only one exists.")
+    parser.add_argument(
+        "--idea",
+        default="",
+        help="Optional natural-language description of what this template represents.",
+    )
+    
+    args = parser.parse_args()
+    
+    df, dataset_dir = load_data(args.dataset)
+    
+    results = match_single_horizon_auto(df, args.template)
+        
+    # Output
+    expression_list = []
+    if not results:
+        print("No matching expressions found.")
+    else:
+        print(f"Generated {len(results)} expressions:\n")
+        # print(f"{'Context':<30} | Expression")
+        # print("-" * 120)
+        
+        for context, expr in results:
+            # print(f"{context:<30} | {expr}")
+            expression_list.append(expr)
+            
+    # Save results to JSON (Always save for debugging)
+    # Use nanosecond precision to avoid collisions when called in a tight loop.
+    timestamp = time.time_ns()
+    json_output = {
+        "template": args.template,
+        "idea": args.idea,
+        "expression_list": expression_list
+    }
+    
+    parts = _parse_dataset_folder_parts(dataset_dir.name)
+    if parts:
+        dataset_id, region, delay_str = parts
+        prefix = f"{_safe_filename_component(dataset_id)}_{_safe_filename_component(region)}_{_safe_filename_component(delay_str)}"
+    else:
+        # Fallback: keep output stable even if dataset folder naming differs.
+        prefix = _safe_filename_component(dataset_dir.name) or "dataset"
+
+    output_file = dataset_dir / f"{prefix}_idea_{timestamp}.json"
+    try:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(json_output, f, indent=4, ensure_ascii=False)
+        print(f"\nSaved idea configuration to: {output_file}")
+    except Exception as e:
+        print(f"Error saving JSON: {e}", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,90 @@
+import json
+import argparse
+from pathlib import Path
+import sys
+
+def load_data_dir(dataset_name=None):
+    script_dir = Path(__file__).resolve().parent
+    workspace_dir = script_dir.parent
+    
+    if not dataset_name:
+        data_root = workspace_dir / "data"
+        if not data_root.exists():
+            print("Error: Data directory not found.", file=sys.stderr)
+            sys.exit(1)
+            
+        subdirs = [d for d in data_root.iterdir() if d.is_dir()]
+        
+        if len(subdirs) == 1:
+            dataset_name = subdirs[0].name
+            print(f"Auto-detected dataset: {dataset_name}", file=sys.stderr)
+            return workspace_dir / "data" / dataset_name
+        elif len(subdirs) > 1:
+            print("Error: Multiple datasets found. Please specify --dataset.", file=sys.stderr)
+            sys.exit(1)
+        else:
+            print("Error: No dataset folders found inside data directory.", file=sys.stderr)
+            sys.exit(1)
+
+    return workspace_dir / "data" / dataset_name
+
+def main():
+    parser = argparse.ArgumentParser(description="Merge all generated expressions from idea JSON files.")
+    parser.add_argument("--dataset", help="Name of the dataset folder containing idea JSONs.")
+    parser.add_argument("--output", default="final_expressions.json", help="Output filename.")
+    
+    args = parser.parse_args()
+    
+    dataset_dir = load_data_dir(args.dataset)
+    
+    if not dataset_dir.exists():
+        print(f"Error: Dataset directory {dataset_dir} does not exist.", file=sys.stderr)
+        sys.exit(1)
+        
+    all_expressions = []
+    
+    # Find all idea json files (supports idea_*.json and *_idea_*.json)
+    json_files = list(dataset_dir.glob("idea_*.json"))
+    if not json_files:
+        json_files = list(dataset_dir.glob("*_idea_*.json"))
+    
+    if not json_files:
+        print(f"No idea_*.json files found in {dataset_dir}", file=sys.stderr)
+        sys.exit(0)
+        
+    print(f"Found {len(json_files)} idea files. Merging...")
+    
+    for jf in json_files:
+        try:
+            with open(jf, 'r') as f:
+                data = json.load(f)
+                exprs = data.get("expression_list", [])
+                if exprs:
+                    all_expressions.extend(exprs)
+                    print(f"  + {jf.name}: {len(exprs)} expressions")
+                else:
+                    print(f"  - {jf.name}: 0 expressions")
+        except Exception as e:
+            print(f"  ! Error reading {jf.name}: {e}", file=sys.stderr)
+            
+    # Remove duplicates if desired? Usually we keep them or set them. 
+    # Let's make unique to be safe, but preserve order as best as possible.
+    unique_expressions = []
+    seen = set()
+    for ex in all_expressions:
+        if ex not in seen:
+            unique_expressions.append(ex)
+            seen.add(ex)
+            
+    output_path = dataset_dir / args.output
+    
+    try:
+        with open(output_path, 'w') as f:
+            json.dump(unique_expressions, f, indent=4)
+        print(f"\nSuccessfully merged {len(unique_expressions)} unique expressions.")
+        print(f"Output saved to: {output_path}")
+    except Exception as e:
+        print(f"Error saving output: {e}", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

cnhkmcp/untracked/APP/trailSomeAlphas/skills/brain-feature-implementation/scripts/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',383),
+  ('expression -> expression EQUAL comparison','expression',3,'p_expression','validator.py',384),
+  ('expression -> expression NOTEQUAL comparison','expression',3,'p_expression','validator.py',385),
+  ('expression -> expression GREATER comparison','expression',3,'p_expression','validator.py',386),
+  ('expression -> expression LESS comparison','expression',3,'p_expression','validator.py',387),
+  ('expression -> expression GREATEREQUAL comparison','expression',3,'p_expression','validator.py',388),
+  ('expression -> expression LESSEQUAL comparison','expression',3,'p_expression','validator.py',389),
+  ('comparison -> term','comparison',1,'p_comparison','validator.py',396),
+  ('comparison -> comparison PLUS term','comparison',3,'p_comparison','validator.py',397),
+  ('comparison -> comparison MINUS term','comparison',3,'p_comparison','validator.py',398),
+  ('term -> factor','term',1,'p_term','validator.py',405),
+  ('term -> term TIMES factor','term',3,'p_term','validator.py',406),
+  ('term -> term DIVIDE factor','term',3,'p_term','validator.py',407),
+  ('factor -> NUMBER','factor',1,'p_factor','validator.py',414),
+  ('factor -> STRING','factor',1,'p_factor','validator.py',415),
+  ('factor -> FIELD','factor',1,'p_factor','validator.py',416),
+  ('factor -> CATEGORY','factor',1,'p_factor','validator.py',417),
+  ('factor -> IDENTIFIER','factor',1,'p_factor','validator.py',418),
+  ('factor -> BOOLEAN','factor',1,'p_factor','validator.py',419),
+  ('factor -> MINUS factor','factor',2,'p_factor','validator.py',420),
+  ('factor -> LPAREN expression RPAREN','factor',3,'p_factor','validator.py',421),
+  ('factor -> function_call','factor',1,'p_factor','validator.py',422),
+  ('function_call -> FUNCTION LPAREN args RPAREN','function_call',4,'p_function_call','validator.py',450),
+  ('args -> arg_list','args',1,'p_args','validator.py',454),
+  ('args -> empty','args',1,'p_args','validator.py',455),
+  ('arg_list -> arg','arg_list',1,'p_arg_list','validator.py',462),
+  ('arg_list -> arg_list COMMA arg','arg_list',3,'p_arg_list','validator.py',463),
+  ('arg -> expression','arg',1,'p_arg','validator.py',470),
+  ('arg -> IDENTIFIER ASSIGN expression','arg',3,'p_arg','validator.py',471),
+  ('empty -> <empty>','empty',0,'p_empty','validator.py',478),
+]