import json import copy import re from collections import defaultdict import secrets import string from typing import Dict, Any, TypedDict from plan_generator_10 import generate_plan,generate_blocks_from_opcodes,all_block_definitions ################################################################################################################################################################# #--------------------------------------------------[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)) ################################################################################################################################################################# #--------------------------------------------------[Processed the two Skelton as input and generate refined skelton json]---------------------------------------- ################################################################################################################################################################# def process_scratch_blocks(all_generated_blocks, generated_output_json): processed_blocks = {} # 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)) for block_id, gen_block_data in generated_output_json.items(): processed_block = {} all_gen_block_data = all_generated_blocks.get(block_id, {}) # Copy and update fields, inputs, next, parent, shadow, topLevel, mutation, and opcode processed_block["opcode"] = all_gen_block_data.get("op_code", gen_block_data.get("op_code")) processed_block["inputs"] = {} processed_block["fields"] = {} processed_block["shadow"] = all_gen_block_data.get("shadow", gen_block_data.get("shadow")) processed_block["topLevel"] = all_gen_block_data.get("topLevel", gen_block_data.get("topLevel")) processed_block["parent"] = all_gen_block_data.get("parent", gen_block_data.get("parent")) processed_block["next"] = all_gen_block_data.get("next", gen_block_data.get("next")) if "mutation" in all_gen_block_data: processed_block["mutation"] = all_gen_block_data["mutation"] # Process inputs if "inputs" in all_gen_block_data: for input_name, input_data in all_gen_block_data["inputs"].items(): if input_name in ["SUBSTACK", "CONDITION"]: # These should always be type 2 if isinstance(input_data, list) and len(input_data) == 2: processed_block["inputs"][input_name] = [2, input_data[1]] elif isinstance(input_data, dict) and input_data.get("kind") == "block": processed_block["inputs"][input_name] = [2, input_data.get("block")] else: # Fallback for unexpected formats, try to use the original if possible processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [2, None]) elif isinstance(input_data, dict): if input_data.get("kind") == "value": # Case 1: Direct value input processed_block["inputs"][input_name] = [ 1, [ 4, str(input_data.get("value", "")) ] ] elif input_data.get("kind") == "block": # Case 3: Nested block input existing_shadow_value = "" if input_name in gen_block_data.get("inputs", {}) and \ isinstance(gen_block_data["inputs"][input_name], list) and \ len(gen_block_data["inputs"][input_name]) > 2 and \ isinstance(gen_block_data["inputs"][input_name][2], list) and \ len(gen_block_data["inputs"][input_name][2]) > 1: existing_shadow_value = gen_block_data["inputs"][input_name][2][1] processed_block["inputs"][input_name] = [ 3, input_data.get("block", ""), [ 10, # Assuming 10 for number/string shadow existing_shadow_value ] ] elif input_data.get("kind") == "menu": # Handle menu inputs like in event_broadcast menu_option = input_data.get("option", "") # Generate or retrieve a unique ID for the broadcast message broadcast_id = broadcast_id_map[menu_option] # Use defaultdict for unique IDs processed_block["inputs"][input_name] = [ 1, [ 11, # This is typically the code for menu dropdowns menu_option, broadcast_id ] ] elif isinstance(input_data, list): # For cases like TOUCHINGOBJECTMENU, where input_data is a list [1, "block_id"] processed_block["inputs"][input_name] = input_data # Process fields if "fields" in all_gen_block_data: for field_name, field_value in all_gen_block_data["fields"].items(): if field_name == "VARIABLE" and isinstance(field_value, list) and len(field_value) > 0: # Generate or retrieve a unique ID for the variable variable_name = field_value[0] unique_id = variable_id_map[variable_name] # Use defaultdict for unique IDs processed_block["fields"][field_name] = [ variable_name, unique_id ] elif field_name == "STOP_OPTION": processed_block["fields"][field_name] = [ field_value[0], None ] elif field_name == "TOUCHINGOBJECTMENU": referenced_menu_block_id = all_gen_block_data["inputs"].get("TOUCHINGOBJECTMENU", [None, None])[1] if referenced_menu_block_id and referenced_menu_block_id in all_generated_blocks: menu_block = all_generated_blocks[referenced_menu_block_id] menu_value = menu_block.get("fields", {}).get("TOUCHINGOBJECTMENU", ["", None])[0] processed_block["fields"][field_name] = [menu_value, None] else: processed_block["fields"][field_name] = [field_value[0], None] else: processed_block["fields"][field_name] = field_value # Remove unwanted keys from the processed block keys_to_remove = ["functionality", "block_shape", "id", "block_name", "block_type"] for key in keys_to_remove: if key in processed_block: del processed_block[key] processed_blocks[block_id] = processed_block return processed_blocks ################################################################################################################################################################# #--------------------------------------------------[Unique secret key for skelton json to make sure it donot overwrite each other]------------------------------- ################################################################################################################################################################# def rename_blocks(block_json: dict, opcode_count: dict) -> tuple[dict, dict]: """ 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]]---------------- ################################################################################################################################################################# def variable_intialization(project_data): """ Updates variable and broadcast definitions in a Scratch project JSON, populating the 'variables' and 'broadcasts' sections of the Stage target and extracting initial values for variables. Args: project_data (dict): The loaded JSON data of the Scratch project. Returns: dict: The updated project JSON data. """ stage_target = None for target in project_data['targets']: if target.get('isStage'): stage_target = target break if stage_target is None: print("Error: Stage target not found in the project data.") return project_data # Ensure 'variables' and 'broadcasts' exist in the Stage target if "variables" not in stage_target: stage_target["variables"] = {} if "broadcasts" not in stage_target: stage_target["broadcasts"] = {} # Helper function to recursively find and update variable/broadcast fields def process_dict(obj): if isinstance(obj, dict): # Check for "data_setvariableto" opcode to extract initial values if obj.get("opcode") == "data_setvariableto": variable_field = obj.get("fields", {}).get("VARIABLE") value_input = obj.get("inputs", {}).get("VALUE") if variable_field and isinstance(variable_field, list) and len(variable_field) == 2: var_name = variable_field[0] var_id = variable_field[1] initial_value = "" if value_input and isinstance(value_input, list) and len(value_input) > 1 and \ isinstance(value_input[1], list) and len(value_input[1]) > 1: # Extract value from various formats, e.g., [1, [10, "0"]] or [3, [12, "score", "id"], [10, "0"]] if value_input[1][0] == 10: # Direct value like [10, "0"] initial_value = str(value_input[1][1]) elif value_input[1][0] == 12 and len(value_input) > 2 and isinstance(value_input[2], list) and value_input[2][0] == 10: # Variable reference with initial value block initial_value = str(value_input[2][1]) elif isinstance(value_input[1], (str, int, float)): # For direct number/string inputs initial_value = str(value_input[1]) # Add/update the variable in the Stage's 'variables' with its initial value stage_target["variables"][var_id] = [var_name, initial_value] for key, value in obj.items(): # Process variable definitions in 'fields' (for blocks that define variables like 'show variable') if key == "VARIABLE" and isinstance(value, list) and len(value) == 2: var_name = value[0] var_id = value[1] # Only add if not already defined with an initial value from set_variableto if var_id not in stage_target["variables"]: stage_target["variables"][var_id] = [var_name, ""] # Default to empty string if no initial value found yet elif stage_target["variables"][var_id][0] != var_name: # Update name if ID exists but name is different stage_target["variables"][var_id][0] = var_name # Process broadcast definitions in 'inputs' (BROADCAST_INPUT) elif key == "BROADCAST_INPUT" and isinstance(value, list) and len(value) == 2 and \ isinstance(value[1], list) and len(value[1]) == 3 and value[1][0] == 11: broadcast_name = value[1][1] broadcast_id = value[1][2] # Add/update the broadcast in the Stage's 'broadcasts' stage_target["broadcasts"][broadcast_id] = broadcast_name # Process broadcast definitions in 'fields' (BROADCAST_OPTION) elif key == "BROADCAST_OPTION" and isinstance(value, list) and len(value) == 2: broadcast_name = value[0] broadcast_id = value[1] # Add/update the broadcast in the Stage's 'broadcasts' stage_target["broadcasts"][broadcast_id] = broadcast_name # Recursively call for nested dictionaries or lists process_dict(value) elif isinstance(obj, list): for i, item in enumerate(obj): # Process variable references in 'inputs' (like [12, "score", "id"]) if isinstance(item, list) and len(item) == 3 and item[0] == 12: var_name = item[1] var_id = item[2] # Only add if not already defined with an initial value from set_variableto if var_id not in stage_target["variables"]: stage_target["variables"][var_id] = [var_name, ""] # Default to empty string if no initial value found yet elif stage_target["variables"][var_id][0] != var_name: # Update name if ID exists but name is different stage_target["variables"][var_id][0] = var_name process_dict(item) # Iterate through all targets to process their blocks for target in project_data['targets']: if "blocks" in target: for block_id, block_data in target["blocks"].items(): process_dict(block_data) return project_data def deduplicate_variables(project_data): """ Removes duplicate variable entries in the 'variables' dictionary of the Stage target, prioritizing entries with non-empty values. Args: project_data (dict): The loaded JSON data of the Scratch project. Returns: dict: The updated project JSON data with deduplicated variables. """ stage_target = None for target in project_data['targets']: if target.get('isStage'): stage_target = target break if stage_target is None: print("Error: Stage target not found in the project data.") return project_data if "variables" not in stage_target: return project_data # No variables to deduplicate # Use a temporary dictionary to store the preferred variable entry by name # Format: {variable_name: [variable_id, variable_name, variable_value]} resolved_variables = {} for var_id, var_info in stage_target["variables"].items(): var_name = var_info[0] var_value = var_info[1] if var_name not in resolved_variables: # If the variable name is not yet seen, add it resolved_variables[var_name] = [var_id, var_name, var_value] else: # If the variable name is already seen, decide which one to keep existing_id, existing_name, existing_value = resolved_variables[var_name] # Prioritize the entry with a non-empty value if var_value != "" and existing_value == "": resolved_variables[var_name] = [var_id, var_name, var_value] # If both have non-empty values, or both are empty, keep the current one (arbitrary choice, but consistent) # The current logic will effectively keep the last one encountered that has a value, # or the very last one if all are empty. elif var_value != "" and existing_value != "": # If there are multiple non-empty values for the same variable name # this keeps the one from the most recent iteration. # For the given example, this will correctly keep "5". resolved_variables[var_name] = [var_id, var_name, var_value] elif var_value == "" and existing_value == "": # If both are empty, just keep the current one (arbitrary) resolved_variables[var_name] = [var_id, var_name, var_value] # Reconstruct the 'variables' dictionary using the resolved entries new_variables_dict = {} for var_name, var_data in resolved_variables.items(): var_id_to_keep = var_data[0] var_name_to_keep = var_data[1] var_value_to_keep = var_data[2] new_variables_dict[var_id_to_keep] = [var_name_to_keep, var_value_to_keep] stage_target["variables"] = new_variables_dict return project_data def variable_adder_main(project_data): try: declare_variable_json= variable_intialization(project_data) except Exception as e: print(f"Error error in the variable initialization opcodes: {e}") try: processed_json= deduplicate_variables(declare_variable_json) return except Exception as e: print(f"Error error in the variable initialization opcodes: {e}") ################################################################################################################################################################# #--------------------------------------------------[Helper main function]---------------------------------------------------------------------------------------- ################################################################################################################################################################# def block_builder(opcode_count,pseudo_code): try: generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(opcode_count, all_block_definitions) except Exception as e: print(f"Error generating blocks from opcodes: {e}") return {} try: all_generated_blocks = generate_plan(generated_output_json, initial_opcode_occurrences, pseudo_code) except Exception as e: print(f"Error generating plan from blocks: {e}") return {} try: processed_blocks= process_scratch_blocks(all_generated_blocks, generated_output_json) except Exception as e: print(f"Error processing Scratch blocks: {e}") return {} renamed_blocks, renamed_counts = rename_blocks(processed_blocks, initial_opcode_occurrences) return renamed_blocks ################################################################################################################################################################# #--------------------------------------------------[Example use of the function here]---------------------------------------------------------------------------- ################################################################################################################################################################# initial_opcode_counts = [ { "opcode": "event_whenflagclicked", "count": 1 }, { "opcode": "data_setvariableto", "count": 2 }, { "opcode": "data_showvariable", "count": 2 }, { "opcode": "event_broadcast", "count": 1 } ] pseudo_code=""" when green flag clicked set [score v] to (0) set [lives v] to (3) show variable [score v] show variable [lives v] broadcast [Game Start v] """ generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(initial_opcode_counts, 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) print(all_generated_blocks) print("--------------\n\n") print(processed_blocks) print("--------------\n\n") print(initial_opcode_occurrences)