Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -2300,9 +2300,12 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
                 menu_block_id = _register_block("control_create_clone_of_menu", key, True, pick_key, all_generated_blocks, fields={"CLONE_OPTION": [option_val, None]})
                 info["inputs"]["CLONE_OPTION"] = {"kind": "block", "block": menu_block_id}
         elif opcode in ["sound_playuntildone", "sound_play"]:
-            m = re.search(r"(?:play sound|start sound)\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            # m = re.search(r"(?:play sound|start sound)\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"(?:play sound|start sound)\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+)\s*\)?)",stmt_for_parse,re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
+                # option = m.group(1).strip()
+                option = m.group(1) or m.group(2)
+                print("sounds option content--------->",option)
                 menu_block_id = _register_block("sound_sounds_menu", key, True, pick_key, all_generated_blocks, fields={"SOUND_MENU": [option, None]})
                 info["inputs"]["SOUND_MENU"] = {"kind": "block", "block": menu_block_id}
         elif opcode == "looks_switchcostumeto":
@@ -3147,8 +3150,10 @@ def _find_all_opcodes(code_block: str) -> list[str]:
         (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"play sound \[.+? v\] until done", "sound_playuntildone"),
+        # (r"start sound \[.+? v\]", "sound_play"),
+        (r"play sound\s+(?:\[\s*.+?\s*v\]|\(?\s*.+?\s*\)?)\s+until done", "sound_playuntildone"),
+        (r"start sound\s+(?:\[\s*.+?\s*v\]|\(?\s*.+?\s*\)?)", "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"),
@@ -3252,49 +3257,75 @@ def analyze_opcode_counts(pseudo_code: str) -> list[dict]:
 #--------------------------------------------------[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.
+
+#     This function finds the start of each "hat" block and slices the
+#     original string to capture the full code block for each script,
+#     providing a more robust and reliable separation.
+
+#     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 with more robust regex.
+#     # We use a non-capturing group (?:...) for the patterns.
+#     # We use a logical OR (|) to combine them into a single pattern.
+#     delimiter_patterns = (
+#         r"when green flag clicked|when flag clicked|when \S+ key pressed|"
+#         r"when this sprite clicked|when backdrop switches to \[.*?\]|"
+#         r"when I receive \[.*?\]|when \[.*?\] > \[.*?\]"
+#     )
+
+#     # Use re.finditer to get an iterator of all hat block matches.
+#     # The `re.DOTALL` flag allows the '.' to match newlines.
+#     matches = list(re.finditer(delimiter_patterns, pseudocode_string, flags=re.DOTALL | re.IGNORECASE))
+
+#     scripts = []
+#     # If no matches are found, return an empty list.
+#     if not matches:
+#         return []
+
+#     # Iterate through the matches to slice the original string.
+#     for i in range(len(matches)):
+#         start = matches[i].start()
+#         end = matches[i+1].start() if i + 1 < len(matches) else len(pseudocode_string)
+        
+#         # Slice the pseudocode string from the start of one match to the start
+#         # of the next, or to the end of the string.
+#         script = pseudocode_string[start:end]
+#         scripts.append(script.strip())
+    
+#     return scripts
 def separate_scripts(pseudocode_string):
     """
-    Separates a block of Scratch pseudocode into a list of individual scripts.
+    Split a block of Scratch pseudocode into individual scripts.
+    Each script starts at a 'when ...' hat block that appears at the start
+    of a line (leading whitespace allowed).
+    """
+    # Robust, non-capturing hat-block patterns (no capturing groups!)
+    patterns = [
+        r"when\s+(?:green\s+flag\s+)?click(?:ed)?\b",                 # when flag clicked / when green flag clicked
+        r"when\s+(?:\S+(?:\s+\S+)*)\s+key\s+press(?:ed)?\b",         # when space key pressed / when up arrow key press
+        r"when\s+this\s+sprite\s+click(?:ed)?\b",                   # when this sprite clicked
+        r"when\s+backdrop\s+switch(?:es|ed)?\s+to\s*\[[^\]]*\]",    # when backdrop switches to [..]
+        r"when\s+I\s+receive(?:d)?\s*\[[^\]]*\]",                   # when I receive [..] / when I received [..]
+        r"when\s*\[[^\]]*\]\s*>\s*\[[^\]]*\]"                       # when [sensor] > [value]
+    ]
 
-    This function finds the start of each "hat" block and slices the
-    original string to capture the full code block for each script,
-    providing a more robust and reliable separation.
+    # Build a lookahead that finds positions just before a hat block at line-start
+    lookahead = r"(?=^\s*(?:{}))".format("|".join(patterns))
 
-    Args:
-        pseudocode_string (str): A string containing Scratch pseudocode.
+    # Use MULTILINE so ^ matches start of lines, DOTALL to allow patterns that may include brackets/newlines as needed
+    parts = re.split(lookahead, pseudocode_string, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL)
+
+    # Filter out empties and strip leading/trailing whitespace/newlines
+    scripts = [p.strip() for p in parts if p and p.strip()]
 
-    Returns:
-        list: A list of strings, where each string is a complete,
-              separated script.
-    """
-    # Define the "hat" block patterns with more robust regex.
-    # We use a non-capturing group (?:...) for the patterns.
-    # We use a logical OR (|) to combine them into a single pattern.
-    delimiter_patterns = (
-        r"when green flag clicked|when flag clicked|when \S+ key pressed|"
-        r"when this sprite clicked|when backdrop switches to \[.*?\]|"
-        r"when I receive \[.*?\]|when \[.*?\] > \[.*?\]"
-    )
-
-    # Use re.finditer to get an iterator of all hat block matches.
-    # The `re.DOTALL` flag allows the '.' to match newlines.
-    matches = list(re.finditer(delimiter_patterns, pseudocode_string, flags=re.DOTALL | re.IGNORECASE))
-
-    scripts = []
-    # If no matches are found, return an empty list.
-    if not matches:
-        return []
-
-    # Iterate through the matches to slice the original string.
-    for i in range(len(matches)):
-        start = matches[i].start()
-        end = matches[i+1].start() if i + 1 < len(matches) else len(pseudocode_string)
-        
-        # Slice the pseudocode string from the start of one match to the start
-        # of the next, or to the end of the string.
-        script = pseudocode_string[start:end]
-        scripts.append(script.strip())
-    
     return scripts
 
 def transform_logic_to_action_flow(source_data, description=""):