Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -3252,49 +3252,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=""):