Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -3254,8 +3254,9 @@ 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.
+    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.
@@ -3264,42 +3265,34 @@ def separate_scripts(pseudocode_string):
         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()]
+    # 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))
 
-    # 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])
-
+    # 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=""):
@@ -3388,16 +3381,16 @@ when I receive [Game Start v]
         end
 end
 """
-# print(pseudo_code)
-# 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(opcode_counts_result)
-# print("--------------\n\n")
-# print(processed_blocks)
-# print("--------------\n\n")
-# print(initial_opcode_occurrences)
-# print("--------------\n\n")
-# print(renamed_blocks)
+print(pseudo_code)
+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(opcode_counts_result)
+print("--------------\n\n")
+print(processed_blocks)
+print("--------------\n\n")
+print(initial_opcode_occurrences)
+print("--------------\n\n")
+print(renamed_blocks)