Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -1,7 +1,7 @@
 import json
 import copy
 import re
-from collections import defaultdict
+from collections import defaultdict, Counter
 import secrets
 import string
 from typing import Dict, Any, TypedDict,Tuple
@@ -2512,8 +2512,8 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
 
     # Initialize dictionaries to store and reuse generated unique IDs
     # This prevents creating multiple unique IDs for the same variable/broadcast across different blocks
-    variable_id_map = defaultdict(lambda: generate_secure_token(20))
-    broadcast_id_map = defaultdict(lambda: generate_secure_token(20))
+    variable_id_map = defaultdict(lambda: generate_secure_token())
+    broadcast_id_map = defaultdict(lambda: generate_secure_token())
 
     # Define the mapping for input field names to their required integer types for shadows
     input_type_mapping = {
@@ -2602,7 +2602,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                     else:
                         # Fallback: try original generated_output_json value if present, else synthesize
                         fallback = gen_block_data.get("inputs", {}).get(input_name,
-                                                                       [1, [11, "message1", generate_secure_token(20)]])
+                                                                       [1, [11, "message1", generate_secure_token()]])
                         processed_block["inputs"][input_name] = fallback
                     continue
 
@@ -3065,6 +3065,281 @@ def variable_adder_main(project_data):
         return processed_json
     except Exception as e:
         print(f"Error error in the variable initialization opcodes: {e}")
+
+#################################################################################################################################################################
+#--------------------------------------------------[Helper function to generate Opcode]--------------------------------------------------------------------------
+#################################################################################################################################################################
+
+def _find_all_opcodes(code_block: str) -> list[str]:
+    """
+    Finds all Scratch opcodes in a given code block using a series of
+    regex patterns. This function is designed to handle multi-line blocks
+    by processing the entire code block and finding all matches. The
+    patterns are ordered from most specific to least specific to prevent
+    misclassification.
+
+    Args:
+        code_block: A string containing the entire pseudo-code.
+
+    Returns:
+        A list of all detected opcode strings.
+    """
+    opcodes = []
+    
+    # Define a list of regex patterns and their corresponding opcodes,
+    # ordered from most specific to least specific. The re.DOTALL flag
+    # allows '.' to match newlines, which is crucial for multi-line blocks.
+    patterns = [
+        # --- Multi-line Control Blocks (most specific, non-greedy) ---
+        (r"if <.+?> then(?:.|\n)+?else(?:.|\n)+?end", "control_if_else"), #(to test muliple stack)
+        (r"forever", "control_forever"),
+        (r"if <.+?> then", "control_if"),
+        (r"repeat until <.+?>", "control_repeat_until"),
+        (r"repeat\s+(?:\(.+?\)|\[.+?(?:\s+v)?\]|\S+)", "control_repeat"),
+        (r"stop\s+(?:all|this script|other scripts in sprite|\[(?:all|this script|other scripts in sprite)(?:\s+v)?\])(?!\s+sounds)", "control_stop"),
+        (r"when I start as a clone", "control_start_as_clone"),
+        (r"create clone of \[.+?(?:\s+v)?\]", "control_create_clone_of"),
+        (r"delete this clone", "control_delete_this_clone"),
+        (r"wait\s+(?:\(.+?\)|\[.+?(?:\s+v)?\]|\S+)\s+sec(?:ond)?s?", "control_wait"),
+        (r"wait until <.+?>", "control_wait_until"),
+
+        # --- Event Blocks (most specific) ---
+        (r"when green flag clicked", "event_whenflagclicked"),
+        (r"when\s+(?:key\s+\[(.+?)(?:\s+v)?\]|\[(.+?)(?:\s+v)?\]\s+key)\s+pressed", "event_whenkeypressed"),
+        (r"when this sprite clicked", "event_whenthisspriteclicked"),
+        (r"when backdrop switches to \[.+?(?:\s+v)?\]", "event_whenbackdropswitchesto"),
+        (r"when I receive \[.+?(?:\s+v)?\]", "event_whenbroadcastreceived"),
+        (r"when \[.+?(?:\s+v)?\] > (.+)", "event_whengreaterthan"),
+        (r"broadcast \[.+?(?:\s+v)?\] and wait", "event_broadcastandwait"),
+        (r"broadcast \[.+?(?:\s+v)?\]", "event_broadcast"),
+
+        # --- Data Blocks (Variables and Lists) - specific block types first ---
+        (r"set\s*\[\s*.+?(?:\s+v)?\s*\]\s*to\s*\(?\s*.+?\s*\)?", "data_setvariableto"),
+        (r"change\s*\[\s*.+?(?:\s+v)?\s*\]\s*by\s*\(?\s*.+?\s*\)?", "data_changevariableby"),
+        (r"show variable \[.+?(?:\s+v)?\]", "data_showvariable"),
+        (r"hide variable \[.+?(?:\s+v)?\]", "data_hidevariable"),
+        (r"show list \[.+?(?:\s+v)?\]", "data_showlist"),
+        (r"hide list \[.+?(?:\s+v)?\]", "data_hidelist"),
+        (r"add\s+(?:\[.+?\]|\(.+?\)|\w+)\s+to\s+\[.+?(?:\s+v)?\]", "data_addtolist"),
+        (r"delete\s*\((?!all\)).+?\)\s*of\s*\[.+?(?:\s+v)?\]", "data_deleteoflist"),
+        (r"delete\s*\(all\)\s*of\s*\[.+?(?:\s+v)?\]", "data_deletealloflist"),
+        (r"insert\s+(\(.+?\)|\[.+?\]|\(\[.+?\]\)|[^\s]+)\s+at\s+(\(.+?\)|\[.+?\]|\(\[.+?\]\)|\d+)\s+of\s+\[.+?(?:\s+v)?\]", "data_insertatlist"),
+        (r"replace\s+item\s+(\(.+?\)|\[\s*.+?\s*(?:v)?\]|[^\s]+)\s+of\s+\[.+?(?:\s+v)?\]\s+with\s+(\(.+?\)|\[\s*.+?\s*(?:v)?\]|.+)","data_replaceitemoflist"),
+        (r"[<(]\s*\[[^\]]+?\s+v\]\s*contains\s*\[[^\]]+?\]\s*\??\s*[)>]", "data_listcontainsitem"),
+        (r"\(item\s+#\s+of\s+\(?(.+?)\)?\s+in\s+\[.+?(?:\s+v)?\]\)", "data_itemnumoflist"),
+        (r"(?<!replace\s)\(?item(?!\s+#)\s+(\(.+?\)|\[\s*.+?\s*(?:v)?\]|[^\s]+)\s+of\s+\[.+?(?:\s+v)?\]\)?", "data_itemoflist"),
+        (r"\(length of \[.+?(?:\s+v)?\]\)", "data_lengthoflist"),
+        
+        # --- Sensing Blocks ---
+        (r"ask \[.+?\] and wait", "sensing_askandwait"),
+        (r"(?<!when\s)key\s+\[.+?(?:\s+v)?\]\s+pressed\??", "sensing_keypressed"),
+        (r"mouse down\??", "sensing_mousedown"),
+        (r"""\s*<?\s*color\s*\[?\s*(#[0-9A-Fa-f]{6})\s*\]?\s*is\s+touching\s*\[?\s*(#[0-9A-Fa-f]{6})\s*\]?\s*\??\s*>?\s*""", "sensing_coloristouchingcolor"),
+        (r"(?<!is\s)touching\s*(?:color\s*)?\[?\s*#([0-9A-Fa-f]{6})\s*\]?\??", "sensing_touchingcolor"),
+        (r"touching \[.+? v\]\??", "sensing_touchingobject"),
+        (r"set drag mode \[.+? v\]", "sensing_setdragmode"),
+        (r"reset timer", "sensing_resettimer"),
+        (r"(?i)(?<!\bat\s)(?<!\bdelete\s)(?<!\binsert\s)(?<!\breplace\s)(?<!\bcreate\s)(?<!\bitem\s)(?<!\bletter\s)"r"(?:"r"\(\s*(?!(?:item\b|\d+|\#|length\b|insert\b|delete\b|replace\b|create\b|letter\b))[^()]{1,200}?\)\s*of\s*\[[^\]]+?(?:\s+v)?\](?!\s*in\s*\[)"r"|"r"\(\s*(?!(?:item\b|\d+|\#|length\b|insert\b|delete\b|replace\b|create\b|letter\b)).*?of\s*\[[^\]]+?(?:\s+v)?\].*?\)"r"|"r"\[\s*(?!(?:item\b|\d+|\#|length\b|letter\b))[^\]]+?\]\s*of\s*\[[^\]]+?(?:\s+v)?\](?!\s*in\s*\[)"r"|"r"\b(?:backdrop|costume|x\s+position|y\s+position|direction|size|volume|loudness|answer|day|month|year|username|timer|mouse\s+x|mouse\s+y)\b\s*of\s*\[[^\]]+?(?:\s+v)?\](?!\s*in\s*\[)"r")","sensing_of"),
+        (r"\(current \[.+? v]\)", "sensing_current"),
+        (r"\(?answer\)?", "sensing_answer"),         #(to test muliple bracket and alone should treet as the keyword)
+        (r"\(?username\)?", "sensing_username"),     #(to test muliple bracket and alone should treet as the keyword)
+        
+        # --- Sound Blocks ---
+        (r"play sound \[.+? v\] until done", "sound_playuntildone"),
+        (r"start sound \[.+? v\]", "sound_play"),
+        (r"stop all sounds", "sound_stopallsounds"),
+        (r"change volume by\s*(?:\((.+?)\)|\[(.+?)\]|(.+))", "sound_changevolumeby"),
+        (r"""set\ volume\ to\s+\(?\s*(?:-?\d+(?:\.\d+)?|\[?[a-zA-Z_][\w\s]*\]?(?:\ v)?)\s*\)?\s*%?""", "sound_setvolumeto"),
+        
+        (r"\(volume\)", "sound_volume"),
+
+        # --- Motion Blocks ---
+        (r"go to x:\s*\(?(.+?)\)?\s*y:\s*\(?(.+?)\)?", "motion_gotoxy"),
+        (r"set x to (.+)", "motion_setx"),
+        (r"set y to (.+)", "motion_sety"),
+        (r"move\s*\(?(.+?)\)?\s*(?:steps?)?", "motion_movesteps"),
+        (r"turn right\s*\(?(.+?)\)?\s*(?:degrees?)?", "motion_turnright"),
+        (r"turn left\s*\(?(.+?)\)?\s*(?:degrees?)?", "motion_turnleft"),
+        (r"go to\s*(?:random position|mouse-pointer|\[.*?\]|.+)", "motion_goto"),   #(to mouse-pointer is not include here for now) 
+        (r"point in direction\s*\(?(.+?)\)?", "motion_pointindirection"),
+        (r"point towards \[.+? v\]", "motion_pointtowards"),
+        (r"change x by\s*\(?(.+?)\)?", "motion_changexby"),
+        (r"change y by\s*\(?(.+?)\)?", "motion_changeyby"),
+        (r"glide\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)\s*to\s*x:\s*\(?(.+?)\)?\s*y:\s*\(?(.+?)\)?", "motion_glidesecstoxy"),
+        (r"glide\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)\s*to\s*\[.*?\]", "motion_glideto"),
+        (r"if on edge, bounce", "motion_ifonedgebounce"),
+        (r"set rotation style\s*\[(?:left-right|all around|don't rotate)(?:\s*v)?\]", "motion_setrotationstyle"),
+        (r"\(?x position\)?", "motion_xposition"), #(to x positon may detect where var is used) 
+        (r"\(?y position\)?", "motion_yposition"), #(to y position  may detect where var is used) 
+        (r"\(?direction\)?", "motion_direction"),  #(to direction  may detect where var is used) 
+        
+        # --- Looks Blocks ---
+        (r"switch costume to \[.+? v\]", "looks_switchcostumeto"),
+        (r"next costume", "looks_nextcostume"),
+        (r"switch backdrop to \[.+? v\] and wait", "looks_switchbackdroptowait"),
+        (r"switch backdrop to \[.+? v\]", "looks_switchbackdropto"),
+        (r"next backdrop", "looks_nextbackdrop"),
+        (r"^\s*show\s*$", "looks_show"),
+        (r"^\s*hide\s*$", "looks_hide"),
+        (r"say\s+(?:\[.+?\]|\(.+?\)|.+?)\s*for\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)", "looks_sayforsecs"),
+        (r"say\s+(?!.*\bfor\b\s*\(?\d+\)?\s*(?:sec|secs|second|seconds))(?:\[.+?\]|\(.+?\)|.+?)", "looks_say"),
+        (r"think\s*\[.+?\]\s*for\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)", "looks_thinkforsecs"),
+        (r"think\s*\[.+?\]", "looks_think"),
+        (r"change size by\s*\(?(.+?)\)?", "looks_changesizeby"),
+        (r"set size to\s*\(?(.+?)\)?\s*%?", "looks_setsizeto"),
+        (r"change\s*\[(.+?)(?:\s*v)?\]\s*effect by\s*\(?(.+?)\)?", "looks_changeeffectby"),
+        (r"set\s*\[(.+?)(?:\s*v)?\]\s*effect to\s*\(?(.+?)\)?", "looks_seteffectto"),
+        (r"clear graphic effects", "looks_cleargraphiceffects"),
+        (r"\(costume \[.+? v\]\)", "looks_costumenumbername"),
+        (r"\(backdrop \[.+? v\]\)", "looks_backdropnumbername"),
+
+        # --- Operators ---
+        (r"<\s*[^<>?]+\s*<\s*[^<>?]+\s*>", "operator_lt"),
+        (r"<\s*[^<>?]+\s*=\s*[^<>?]+\s*>", "operator_equals"),
+        (r"<\s*[^<>?]+\s*>\s*[^<>?]+\s*>", "operator_gt"),
+        (r"<\s*.*?\s+and\s+.*?\s*>", "operator_and"),
+        (r"<\s*.*?\s+or\s+.*?\s*>", "operator_or"),
+        (r"<\s*not\s+.*?\s*>", "operator_not"),
+        (r"(?:\(join\s+(.+?)\s+(.+?)\)|join\s+(.+?)\s+(.+?))", "operator_join"),
+        (r"\(\s*.+?\s*\+\s*.+?\s*\)", "operator_add"),
+        (r"\(\s*(?!-\s*\d+(?:\.\d+)?\s*\))(.+?)\s+-\s+(.+?)\)", "operator_subtract"),
+        (r"\(\s*.+?\s*\*\s*.+?\s*\)", "operator_multiply"),
+        (r"\(\s*.+?\s*/\s*.+?\s*\)", "operator_divide"),
+        (r"\(pick random\s+(.+?)\s+to\s+(.+?)\)", "operator_random"),
+        (r"\(letter\s+(.+?)\s+of\s+(.+?)\)", "operator_letterof"),
+        (r"\(length of\s+(.+?)\)", "operator_length"),
+        (r"\(\s*.+?\s+mod\s+.+?\s*\)", "operator_mod"),
+        (r"\(round\s+(.+?)\)", "operator_round"),
+        (r"[<(]\s*\[(?![^\]]*\s+v\])[^\]]+?\]\s*contains\s*\[[^\]]+?\]\s*\??\s*[)>]", "operator_contains"),
+        (r"\(\s*\[?(abs|floor|ceiling|sqrt|sin|cos|tan|asin|acos|atan|ln|log|e \^|10 \^)\s*(?:v)?\]?\s+of\s+.+?\)", "operator_mathop"),
+
+    ]
+
+    for pattern, opcode in patterns:
+        for match in re.finditer(pattern, code_block, re.DOTALL):
+            opcodes.append(opcode)
+            
+    return opcodes
+
+def analyze_opcode_counts(pseudo_code: str) -> list[dict]:
+    """
+    Analyzes a block of Scratch-like pseudo-code to count the occurrences
+    of each opcode using a multi-pass, regex-based classifier.
+
+    Args:
+        pseudo_code: A string containing the pseudo-code.
+
+    Returns:
+        A list of dictionaries, where each dictionary contains the opcode
+        and its count.
+    """
+    opcode_counts = Counter()
+
+    opcodes_in_code = _find_all_opcodes(pseudo_code)
+    for opcode in opcodes_in_code:
+        opcode_counts[opcode] += 1
+    
+    result = [{"opcode": opcode, "count": count} for opcode, count in opcode_counts.items()]
+    
+    # Sort the result by opcode for consistent output.
+    result.sort(key=lambda x: x['opcode'])
+    
+    return result
+
+#################################################################################################################################################################
+#--------------------------------------------------[Helper function to seperate an correct the json]-------------------------------------------------------------
+#################################################################################################################################################################
+
+def separate_scripts(pseudocode_string):
+    """
+    Separates a block of Scratch pseudocode into a list of individual scripts.
+
+    The function splits the pseudocode at specific "hat" block strings
+    and keeps the hat block as the beginning of each new script.
+
+    Args:
+        pseudocode_string (str): A string containing Scratch pseudocode.
+
+    Returns:
+        list: A list of strings, where each string is a complete,
+              separated script.
+    """
+    # Define the "hat" block patterns. The parentheses around each pattern
+    # are a "capturing group," which tells re.split() to include the
+    # delimiter in the output.
+    delimiter_patterns = [
+        r"when green flag clicked",
+        r"when .*? key pressed",
+        r"when this sprite clicked",
+        r"when backdrop switches to \[.*?\]",
+        r"when \[.*?\] > \[.*?\]",
+        r"when I receive \[.*?\]"
+    ]
+
+    # Join the patterns with a logical OR (|) to create a single regex pattern.
+    combined_pattern = "|".join(f"({p})" for p in delimiter_patterns)
+
+    # Split the string using the combined pattern. The re.DOTALL flag
+    # ensures that the dot (.) matches newline characters as well.
+    # The result will be an alternating list of captured delimiters and the text
+    # that follows them.
+    split_result = re.split(combined_pattern, pseudocode_string, flags=re.DOTALL)
+    
+    # Filter out empty strings that result from the split
+    filtered_list = [item for item in split_result if item and item.strip()]
+
+    # Reassemble the scripts by pairing the delimiters with their corresponding
+    # code blocks. The split result will look something like:
+    # ['delimiter1', 'code block1', 'delimiter2', 'code block2']
+    # We want to combine these pairs.
+    scripts = []
+    # Loop through the list two items at a time
+    for i in range(0, len(filtered_list), 2):
+        if i + 1 < len(filtered_list):
+            scripts.append(filtered_list[i] + filtered_list[i+1])
+        else:
+            scripts.append(filtered_list[i])
+
+    return scripts
+
+def transform_logic_to_action_flow(source_data, description=""):
+    """
+    Transforms a 'refined_logic' JSON structure into an 'action_overall_flow' structure.
+
+    Args:
+        source_data (dict): The input dictionary with 'refined_logic', 'name_variable',
+                             and 'pseudocode' keys.
+        description (str): A description to be added to the output structure.
+
+    Returns:
+        dict: A dictionary in the desired 'action_overall_flow' format.
+    """
+    # Check if the required keys exist in the source data
+    if "refined_logic" not in source_data or \
+       "name_variable" not in source_data["refined_logic"] or \
+       "pseudocode" not in source_data["refined_logic"]:
+        raise ValueError("Input dictionary is missing required keys: 'refined_logic', 'name_variable', or 'pseudocode'.")
+
+    # Extract the name and the pseudocode list from the source data
+    name_variable = source_data["refined_logic"]["name_variable"]
+    pseudocode_list = source_data["refined_logic"]["pseudocode"]
+
+    # Transform the list of pseudocode strings into a list of dictionaries
+    # with the "logic" key.
+    plans_list = [{"logic": logic_block} for logic_block in pseudocode_list]
+
+    # Construct the final nested dictionary structure
+    transformed_data = {
+        "action_overall_flow": {
+            name_variable: {
+                "description": description,
+                "plans": plans_list
+            }
+        }
+    }
+
+    return transformed_data
+
 #################################################################################################################################################################
 #--------------------------------------------------[Helper main function]----------------------------------------------------------------------------------------
 #################################################################################################################################################################
@@ -3114,11 +3389,12 @@ when I receive [Game Start v]
 end
 """
 # print(pseudo_code)
-# generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(initial_opcode_counts, all_block_definitions)
+# opcode_counts_result = analyze_opcode_counts(pseudo_code)
+# generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(opcode_counts_result, all_block_definitions)
 # all_generated_blocks = generate_plan(generated_output_json, initial_opcode_occurrences, pseudo_code)
 # processed_blocks= process_scratch_blocks(all_generated_blocks, generated_output_json)
 # renamed_blocks, renamed_counts = rename_blocks(processed_blocks, initial_opcode_occurrences)
-# #print(all_generated_blocks)
+# print(opcode_counts_result)
 # print("--------------\n\n")
 # print(processed_blocks)
 # print("--------------\n\n")