Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -260,7 +260,7 @@ all_block_definitions = {
         "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
     },
     "control_if_else": {
-        "block_name": "if <> then else", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_if_else",
+        "block_name": "if <> then go else", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_if_else",
         "functionality": "Executes one set of blocks if the specified boolean condition is true, and a different set of blocks if the condition is false. [NOTE: it takes boolean blocks as input]",
         "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None], "SUBSTACK2": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
     },
@@ -1867,7 +1867,7 @@ def classify(line):
     if l.startswith("wait until <"): return "control_wait_until", "stack"
     if l.startswith("repeat ("): return "control_repeat", "c_block"
     if l == "forever": return "control_forever", "c_block"
-    if l.startswith("if <") and " then else" in l: return "control_if_else", "c_block"
+    if l.startswith("if <") and " then go" in l: return "control_if_else", "c_block"
     if l.startswith("if <"): return "control_if", "c_block"
     if l.startswith("repeat until <"): return "control_repeat_until", "c_block"
     # Updated regex for stop block to handle different options
@@ -1924,38 +1924,26 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
     """
     Build a nested “plan” tree from:
       • generated_input: dict of block_key -> block_data (pre-generated block definitions)
-      • opcode_keys:    dict of opcode -> list of block_keys (in order)
-      • pseudo_code:    a multiline string, indented with two‑space levels
+      • opcode_keys:     dict of opcode -> list of block_keys (in order)
+      • pseudo_code:     a multiline string, indented with two-space levels
 
     Returns:
         { "flow": [ ... list of block dictionaries ... ] }
     """
-    # helper: pick next unused block_key for an opcode
     ptrs = defaultdict(int)
     def pick_key(opcode):
         lst = opcode_keys.get(opcode, [])
         idx = ptrs[opcode]
         if idx >= len(lst):
-            # Fallback: if no more pre-generated keys, create a new one.
-            # This should ideally not happen if initial_opcode_counts is comprehensive
             ptrs[opcode] += 1
             return f"{opcode}_{idx + 1}"
         ptrs[opcode] += 1
         return lst[idx]
 
-    all_generated_blocks = {} # This will store the final, structured blocks
-
-    # Populate all_generated_blocks with initial blocks, ensuring they have IDs
-    for key, block_data in generated_input.items():
-        all_generated_blocks[key] = copy.deepcopy(block_data)
-        all_generated_blocks[key]["id"] = key # Ensure ID is set
-
-    # Stack stores (indent, owner_block_id, last_block_in_current_linear_chain_id)
-    # owner_block_id: The ID of the C-block or Hat block that owns the current substack.
-    # last_block_in_current_linear_chain_id: The ID of the last block added to the *current linear sequence* within this substack.
-    stack = [(-2, None, None)] # Sentinel: (indent, owner_block_id, last_block_in_current_linear_chain_id)
-                               # Using -2 for initial indent to be less than any valid indent (0 or more)
+    # Change: Start with an empty dictionary. Blocks will be added only as they are parsed.
+    all_generated_blocks = {}
 
+    stack = [(-2, None, None)]
     top_level_script_keys = []
 
     lines = pseudo_code.splitlines()
@@ -1963,150 +1951,114 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
     while i < len(lines):
         raw_line = lines[i]
         stripped_line = raw_line.strip()
-        print("Stripped line here -----1---->", stripped_line)
-        # Skip empty lines and comments
+        
         if not stripped_line or stripped_line.startswith("//"):
             i += 1
             continue
 
         current_indent = (len(raw_line) - len(raw_line.lstrip())) // 2
 
-        # Handle 'else' and 'end' first, as they control scope
         if stripped_line.lower() == "else":
             # Pop the 'then' substack's scope
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
                 all_generated_blocks[popped_last_block_in_chain]["next"] = None
 
-            # The 'if-else' block (popped_owner_key) is the owner.
-            # This 'else' must belong to the current owner on top of the stack (which should be the if-else block)
-            # Ensure the current_owner_block_id is indeed an if-else block
-            if popped_owner_key and all_generated_blocks[popped_owner_key]["op_code"] == "control_if_else":
+            # Check if the popped scope's owner is an IF block.
+            # This check now looks for any C-Block, which is correct for this context.
+            if popped_owner_key and all_generated_blocks[popped_owner_key]["block_shape"] == "C-Block":
+                
+                # This is the crucial step that fixes the issue.
+                # We explicitly upgrade the block from a 'control_if' to a 'control_if_else'.
+                owner_block = all_generated_blocks[popped_owner_key]
+                owner_block["op_code"] = "control_if_else"
+                
                 # Push a new scope for the 'else' substack, with the same owner.
-                stack.append((current_indent, popped_owner_key, None)) # New scope for 'else' part, no last block yet
+                stack.append((current_indent, popped_owner_key, None))
             else:
-                # Error: 'else' found without a preceding 'if' or incorrect nesting
+                # This is the error you were getting.
+                # It happens because the 'if' block was never correctly upgraded.
                 print(f"Error: 'else' found without a corresponding 'if-else' block at line {i+1}")
-                # Attempt to recover by treating it as a regular block or skipping
-                stack.append((popped_indent, popped_owner_key, popped_last_block_in_chain)) # Put back what was popped
+                stack.append((popped_indent, popped_owner_key, popped_last_block_in_chain))
             i += 1
             continue
 
         if stripped_line.lower() == "end":
-            # Pop the current substack's scope
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
-                print("popped_last_block_in_chain is executed here")
                 all_generated_blocks[popped_last_block_in_chain]["next"] = None
             
-            # If the popped scope had an owner (C-block or procedure definition),
-            # and its substack input isn't already filled, set it to None (empty substack).
             if popped_owner_key:
                 owner_block = all_generated_blocks[popped_owner_key]
                 if owner_block["block_shape"] == "C-Block" or owner_block["op_code"] == "procedures_definition":
-                    # Determine which substack this 'end' is closing
-                    # This logic needs to be smarter for if-else
                     if owner_block["op_code"] == "control_if_else":
-                        # If we just popped the 'then' branch (SUBSTACK)
-                        # and SUBSTACK2 is not yet set, then this 'end' closes SUBSTACK.
-                        # If SUBSTACK2 was already set, this 'end' closes SUBSTACK2.
-                        # If neither is filled, it's an empty 'then' branch.
-                        if owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is not None and \
-                           (not owner_block["inputs"].get("SUBSTACK2") or owner_block["inputs"]["SUBSTACK2"][1] is None):
-                            # This 'end' closes the first substack (then branch)
-                            pass # Already handled by the stack logic
-                        elif owner_block["inputs"].get("SUBSTACK2") and owner_block["inputs"]["SUBSTACK2"][1] is not None:
-                            # This 'end' closes the second substack (else branch)
-                            pass # Already handled by the stack logic
-                        else: # Neither substack was filled, meaning an empty 'then' branch
-                            # For now, ensure it's not set to a block ID if it was empty.
-                            if "SUBSTACK" in owner_block["inputs"] and owner_block["inputs"]["SUBSTACK"][1] is None:
-                                pass # Already None
-                            if "SUBSTACK2" in owner_block["inputs"] and owner_block["inputs"]["SUBSTACK2"][1] is None:
-                                pass # Already None
-                    elif owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is None: # Only set if not already set by a block
-                        owner_block["inputs"]["SUBSTACK"] = [2, None] # No blocks in substack
+                        if owner_block["inputs"].get("SUBSTACK2") and owner_block["inputs"]["SUBSTACK2"][1] is not None:
+                            pass
+                        else:
+                            pass
+                    elif owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is None:
+                        owner_block["inputs"]["SUBSTACK"] = [2, None]
             i += 1
             continue
 
-        # Adjust stack based on indentation for regular blocks
-        # Pop scopes whose indentation is greater than or equal to the current line's indentation
         while len(stack) > 1 and stack[-1][0] >= current_indent:
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
-                all_generated_blocks[popped_last_block_in_chain]["next"] = None # Terminate the chain
+                all_generated_blocks[popped_last_block_in_chain]["next"] = None
 
-        # Get the current active scope from the stack
         current_scope_indent, current_owner_block_id, last_block_in_current_chain = stack[-1]
 
-        # Classify the statement and create the block
-        #stmt_for_parse = stripped_line.rstrip("then").strip()
-        stmt_for_parse = re.sub(r"\bthen\s*$", "", stripped_line, flags=re.IGNORECASE).strip()
-        print("befor the classify hit here: ",stmt_for_parse)
-        opcode, ntype = classify(stmt_for_parse)
-        print("the opcode classify: ",opcode)
-        if opcode is None: # Should not happen if classify is robust
+        opcode, ntype = classify(stripped_line)
+        stmt_for_parse = re.sub(r"\bthen(\s+go)?\s*$", "", stripped_line, flags=re.IGNORECASE).strip()
+        print("The opcode here is",opcode)
+        print("The ntype here is",ntype)
+        if opcode is None:
             i += 1
             continue
 
-        # Create the new block (and register it in all_generated_blocks)
-        # _register_block now only sets parent for shadow/input blocks; main block parent/next/topLevel set here.
         key = pick_key(opcode)
-        # Ensure the block exists in all_generated_blocks before trying to access it
+        
+        # Change: The code now relies on this check to create a block only if it's new.
         if key not in all_generated_blocks:
-            # If not pre-generated, create a basic entry. This is a fallback.
-            all_generated_blocks[key] = copy.deepcopy(all_block_definitions.get(opcode, {}))
+            all_generated_blocks[key] = copy.deepcopy(generated_input.get(key, all_block_definitions.get(opcode, {})))
             all_generated_blocks[key]["id"] = key
             all_generated_blocks[key]["inputs"] = all_generated_blocks[key].get("inputs", {})
             all_generated_blocks[key]["fields"] = all_generated_blocks[key].get("fields", {})
-            # Removed sub_stacks from here
 
         info = all_generated_blocks[key]
-
-        # Set parent, next, and topLevel for the main script blocks
+        
         if ntype == "hat":
             info["parent"] = None
             info["topLevel"] = True
             top_level_script_keys.append(key)
-            # Push a new scope for the children of this hat block.
-            stack.append((current_indent, key, None)) # New scope: owner is this hat, no last block yet
-        else: # Stack block or C-block (that is part of a linear sequence)
+            stack.append((current_indent, key, None))
+        else:
             if last_block_in_current_chain:
-                # This block's parent is the previous block in the chain
                 info["parent"] = last_block_in_current_chain
                 all_generated_blocks[last_block_in_current_chain]["next"] = key
             else:
-                # This is the first block in a new linear chain (e.g., first block inside a forever loop)
-                # Its parent is the owner of the current scope (the C-block or Hat block)
                 info["parent"] = current_owner_block_id
                 
-                # If the owner is a C-block or procedure definition, link its SUBSTACK input
                 if current_owner_block_id and (all_generated_blocks[current_owner_block_id]["block_shape"] == "C-Block" or all_generated_blocks[current_owner_block_id]["op_code"] == "procedures_definition"):
                     owner_block = all_generated_blocks[current_owner_block_id]
                     if owner_block["op_code"] == "control_if_else":
-                        # If SUBSTACK is already set, this means we are starting SUBSTACK2 (else part)
                         if owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is not None and \
                            (not owner_block["inputs"].get("SUBSTACK2") or owner_block["inputs"]["SUBSTACK2"][1] is None):
                             owner_block["inputs"]["SUBSTACK2"] = [2, key]
-                        else: # This should be the first substack (then part)
+                        else:
                             owner_block["inputs"]["SUBSTACK"] = [2, key]
-                    elif not owner_block["inputs"].get("SUBSTACK") or owner_block["inputs"]["SUBSTACK"][1] is None: # Only set if not already set by a block
+                    elif not owner_block["inputs"].get("SUBSTACK") or owner_block["inputs"]["SUBSTACK"][1] is None:
                         owner_block["inputs"]["SUBSTACK"] = [2, key]
                 elif current_owner_block_id and all_generated_blocks[current_owner_block_id]["block_shape"] == "Hat Block":
-                    # If the owner is a Hat block, this is its first child
                     all_generated_blocks[current_owner_block_id]["next"] = key
             
             info["topLevel"] = False
-            info["next"] = None # Default, will be overwritten if there's a next block
+            info["next"] = None
 
-            # If it's a C-block or define block, it also starts a new inner scope
             if ntype == "c_block" or opcode == "procedures_definition":
-                # Update the current scope's last_block_in_current_chain to this C-block
                 stack[-1] = (current_scope_indent, current_owner_block_id, key)
-                # Push a new scope for the C-block's substack
-                stack.append((current_indent, key, None)) # New scope: owner is this C-block, no last block yet
+                stack.append((current_indent, key, None))
             else:
-                # For regular stack blocks, just update the last_block_in_current_chain for the current scope
                 stack[-1] = (current_scope_indent, current_owner_block_id, key)
 
         # Parse inputs and fields (this part remains largely the same, but ensure parse_reporter_or_value/parse_condition
@@ -2514,9 +2466,36 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
 #--------------------------------------------------[Security key id generation for the better understanding of keys]---------------------------------------------
 #################################################################################################################################################################
 
-def generate_secure_token(length=20):
-    charset = string.ascii_letters + string.digits + "!@#$%^&*()[]{}=+-_~"
-    return ''.join(secrets.choice(charset) for _ in range(length))
+# def generate_secure_token(length=20):
+#     charset = string.ascii_letters + string.digits + "!@#$%^&*()[]{}=+-_~"
+#     return ''.join(secrets.choice(charset) for _ in range(length))
+# conservative, safe alphabet derived from Scratch-style IDs
+_DEFAULT_SCRATCH_ALPHABET = string.ascii_letters + string.digits + "_-"
+_DEFAULT_LENGTH = 20
+
+# small in-memory cache to avoid duplicates in a single run
+_generated_ids_cache = set()
+
+def generate_secure_token() -> str:
+    """
+    Return a single Scratch-style ID string (20 chars long) using a safe alphabet.
+    No input required.
+
+    Notes:
+    - This does NOT check for collisions inside an existing project.json.
+      If you need to guarantee uniqueness with an existing file, use the
+      project-aware generator shared earlier.
+    - Collisions are astronomically unlikely for random 20-char tokens, but
+      the function still avoids duplicates within the same Python process.
+    """
+    alphabet = _DEFAULT_SCRATCH_ALPHABET
+    length = _DEFAULT_LENGTH
+
+    while True:
+        token = "".join(secrets.choice(alphabet) for _ in range(length))
+        if token not in _generated_ids_cache:
+            _generated_ids_cache.add(token)
+            return token
 
 #################################################################################################################################################################
 #--------------------------------------------------[Processed the two Skelton as input and generate refined skelton json]----------------------------------------
@@ -2527,8 +2506,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 = {
@@ -2590,7 +2569,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                         processed_block["inputs"][input_name] = input_data
                     else:
                         # Fallback for unexpected formats, try to use the original if possible
-                        processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [1, [11, "message1", generate_secure_token(20)]])
+                        processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [1, [11, "message1", generate_secure_token()]])
 
                 elif isinstance(input_data, dict):
                     if input_data.get("kind") == "value":
@@ -2856,53 +2835,7 @@ def rename_blocks(block_json: Dict[str, Any], opcode_count: Dict[str, list]) ->
         new_opcode_count[opcode] = [token_map.get(k, k) for k in key_list]
         
     return new_block_json, new_opcode_count
-    """
-    Replace each block key in block_json and each identifier in opcode_count
-    with a newly generated secure token.
-
-    Args:
-        block_json: Mapping of block_key -> block_data.
-        opcode_count: Mapping of opcode -> list of block_keys.
-
-    Returns:
-        A tuple of (new_block_json, new_opcode_count) with updated keys.
-    """
-    # Step 1: Generate a secure token mapping for every existing block key
-    token_map = {}
-    for old_key in block_json.keys():
-        # Ensure uniqueness in the unlikely event of a collision
-        while True:
-            new_key = generate_secure_token()
-            if new_key not in token_map.values():
-                break
-        token_map[old_key] = new_key
-
-    # Step 2: Rebuild block_json with new keys
-    new_block_json = {}
-    for old_key, block in block_json.items():
-        new_key = token_map[old_key]
-        new_block_json[new_key] = block.copy()
-
-        # Update parent and next references
-        if 'parent' in block and block['parent'] in token_map:
-            new_block_json[new_key]['parent'] = token_map[block['parent']]
-        if 'next' in block and block['next'] in token_map:
-            new_block_json[new_key]['next'] = token_map[block['next']]
-
-        # Update inputs if they reference blocks
-        for inp_key, inp_val in block.get('inputs', {}).items():
-            if isinstance(inp_val, list) and len(inp_val) == 2:
-                idx, ref = inp_val
-                if idx in (2, 3) and isinstance(ref, str) and ref in token_map:
-                    new_block_json[new_key]['inputs'][inp_key] = [idx, token_map[ref]]
-
-    # Step 3: Update opcode count map
-    new_opcode_count = {}
-    for opcode, key_list in opcode_count.items():
-        new_opcode_count[opcode] = [token_map.get(k, k) for k in key_list]
-
-    return new_block_json, new_opcode_count
-
+  
 #################################################################################################################################################################
 #--------------------------------------------------[Helper function to add Variables and Broadcasts [USed in main app file for main projectjson]]----------------
 #################################################################################################################################################################