Upload block_relation_builder.py

utils/block_relation_builder.py

@@ -2716,21 +2716,94 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
         # if "KEY_OPTION" in info["fields"] and opcode == "event_whenkeypressed": # For event_whenkeypressed hat block's field
         #     m = re.search(r"when\s*\[([^\]]+)\s*v\] key pressed", stmt_for_parse, re.IGNORECASE)
         #     if m: info["fields"]["KEY_OPTION"] = [m.group(1).strip(), None]
+        # if "KEY_OPTION" in info["fields"] and opcode == "event_whenkeypressed":
+        #     m = re.search(r"when\s*\[([^\]]+)\s*v\]\s*key pressed", stmt_for_parse, re.IGNORECASE)
+        #     if m:
+        #         option = m.group(1).strip()
+        #         # Valid key options
+        #         valid_options = [ "space", "up arrow", "down arrow", "right arrow", "left arrow", "any",
+        #             "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9"] # temporary 
+        #         cleaned = re.sub(r"[^a-z0-9]", "", option.lower()).strip()
+        #         normalized_map = { re.sub(r"[^a-z0-9]", "", v.lower()): v for v in valid_options }
+        #         if cleaned in normalized_map: option_val = normalized_map[cleaned]
+        #         else:
+        #             match = difflib.get_close_matches(cleaned, normalized_map.keys(), n=1, cutoff=0.5)
+        #             if match: option_val = normalized_map[match[0]]
+        #             else: option_val = "space"
+        #         info["fields"]["KEY_OPTION"] = [option_val, None]
         if "KEY_OPTION" in info["fields"] and opcode == "event_whenkeypressed":
-            m = re.search(r"when\s*\[([^\]]+)\s*v\]\s*key pressed", stmt_for_parse, re.IGNORECASE)
+            print("event_whenkeypressed--here")
+            stmt = stmt_for_parse
+
+            # single regex to capture many forms:
+            # - [up arrow], (up arrow)
+            # - when key up arrow pressed
+            # - when up arrow key pressed
+            # - when up arrow pressed
+            pattern = re.compile(
+                r"(?:\[\s*([^\]]+?)\s*\]|\(\s*([^\)]+?)\s*\)|when\s+key\s+([A-Za-z0-9\-\s]+?)\s+pressed|when\s+([A-Za-z0-9\-\s]+?)\s+key\s+pressed|when\s+([A-Za-z0-9\-\s]+?)\s+pressed)",
+                re.IGNORECASE
+            )
+
+            m = pattern.search(stmt)
+            option = ""
             if m:
-                option = m.group(1).strip()
-                # Valid key options
-                valid_options = [ "space", "up arrow", "down arrow", "right arrow", "left arrow", "any",
-                    "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9"] # temporary 
-                cleaned = re.sub(r"[^a-z0-9]", "", option.lower()).strip()
-                normalized_map = { re.sub(r"[^a-z0-9]", "", v.lower()): v for v in valid_options }
-                if cleaned in normalized_map: option_val = normalized_map[cleaned]
+                # pick the first non-empty capture group
+                for g in m.groups():
+                    if g:
+                        option = g.strip()
+                        break
+
+            print("raw extracted option:", repr(option))
+
+            # inline normalization (no def)
+            cleaned = option.lower().strip()
+            # trim surrounding quotes, replace hyphens with spaces, remove trailing " v" like "[x v]"
+            cleaned = re.sub(r'^[\'"]+|[\'"]+$', '', cleaned)
+            cleaned = cleaned.replace('-', ' ')
+            cleaned = re.sub(r'\s+v\s*$', '', cleaned)        # trailing " v"
+            cleaned = re.sub(r'[^\w\s]', '', cleaned)        # remove punctuation
+            cleaned = re.sub(r'\s+', ' ', cleaned).strip()   # collapse spaces
+            print("normalized extracted option:", repr(cleaned))
+
+            # allowed keys (expand as you need)
+            valid_options = [
+                "space", "up arrow", "down arrow", "right arrow", "left arrow", "any",
+                "enter", "tab", "escape", "backspace",
+                "a","b","c","d","e","f","g","h","i","j","k","l","m",
+                "n","o","p","q","r","s","t","u","v","w","x","y","z",
+                "0","1","2","3","4","5","6","7","8","9"
+            ]
+
+            # build normalization map inline
+            normalized_map = {}
+            for v in valid_options:
+                nv = v.lower().replace('-', ' ')
+                nv = re.sub(r'[^\w\s]', '', nv)
+                nv = re.sub(r'\s+', ' ', nv).strip()
+                normalized_map[nv] = v
+
+            option_val = None
+            if cleaned in normalized_map:
+                option_val = normalized_map[cleaned]
+                print("option matched exact:", option_val)
+            else:
+                # fuzzy match as fallback
+                keys = list(normalized_map.keys())
+                match = difflib.get_close_matches(cleaned, keys, n=1, cutoff=0.55)
+                if match:
+                    option_val = normalized_map[match[0]]
+                    print("option fuzzy matched:", option_val)
                 else:
-                    match = difflib.get_close_matches(cleaned, normalized_map.keys(), n=1, cutoff=0.5)
-                    if match: option_val = normalized_map[match[0]]
-                    else: option_val = "space"
-                info["fields"]["KEY_OPTION"] = [option_val, None]
+                    # accept single char or digit
+                    if re.fullmatch(r'[a-z0-9]', cleaned):
+                        option_val = cleaned
+                        print("option single-char accepted:", option_val)
+                    else:
+                        option_val = option if option else cleaned
+                        print("option fallback (unrecognized):", option_val)
+
+            info["fields"]["KEY_OPTION"] = [option_val, None]
         # if "BACKDROP" in info["fields"] and opcode == "event_whenbackdropswitchesto": # For event_whenbackdropswitchesto hat block's field
         #     m = re.search(r"when backdrop switches to\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
         #     if m: info["fields"]["BACKDROP"] = [m.group(1).strip(), None]