Update app.py

app.py

@@ -9,19 +9,30 @@ import pytesseract
 from werkzeug.utils import secure_filename
 from langchain_groq import ChatGroq
 from langgraph.prebuilt import create_react_agent
-from pdf2image import convert_from_path
+from pdf2image import convert_from_path, convert_from_bytes
 from concurrent.futures import ThreadPoolExecutor
 from pdf2image.exceptions import PDFInfoNotInstalledError
 from typing import Dict, TypedDict, Optional, Any
 from langgraph.graph import StateGraph, END
 import uuid
-import shutil, time
+import shutil, time, functools
 from langchain_experimental.open_clip.open_clip import OpenCLIPEmbeddings
 # from matplotlib.offsetbox import OffsetImage, AnnotationBbox
 from io import BytesIO
 from pathlib import Path
 import os
 from utils.block_relation_builder import block_builder, variable_adder_main
+
+def log_execution_time(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        logger.info(f"⏱ {func.__name__} executed in {end_time - start_time:.2f} seconds")
+        return result
+    return wrapper
+
 global pdf_doc
 # ============================== #
 #     INITIALIZE CLIP EMBEDDER   #
@@ -64,7 +75,8 @@ pytesseract.pytesseract.tesseract_cmd = (r'/usr/bin/tesseract')
 
 # poppler_path = r"C:\poppler\Library\bin"
 backdrop_images_path = r"app\blocks\Backdrops"
-sprite_images_path = r"blocks\sprites"
+sprite_images_path = r"app\blocks\sprites"
+code_blocks_image_path = r"app\blocks\code_blocks"
 
 count = 0
 
@@ -74,12 +86,12 @@ STATIC_DIR       = BASE_DIR / "static"
 GEN_PROJECT_DIR  = BASE_DIR / "generated_projects"
 BACKDROP_DIR     = BLOCKS_DIR / "Backdrops"
 SPRITE_DIR       = BLOCKS_DIR / "sprites"
-
+CODE_BLOCKS_DIR  = BLOCKS_DIR / "code_blocks"
 # === new: outputs rooted under BASE_DIR ===
 OUTPUT_DIR       = BASE_DIR / "outputs"
-DETECTED_IMAGE_DIR = OUTPUT_DIR / "DETECTED_IMAGE"
-SCANNED_IMAGE_DIR  = OUTPUT_DIR / "SCANNED_IMAGE"
-JSON_DIR           = OUTPUT_DIR / "EXTRACTED_JSON"
+# DETECTED_IMAGE_DIR = OUTPUT_DIR / "DETECTED_IMAGE"
+# SCANNED_IMAGE_DIR  = OUTPUT_DIR / "SCANNED_IMAGE"
+# JSON_DIR           = OUTPUT_DIR / "EXTRACTED_JSON"
 
 # make all of them in one go
 for d in (
@@ -88,10 +100,11 @@ for d in (
     GEN_PROJECT_DIR,
     BACKDROP_DIR,
     SPRITE_DIR,
+    CODE_BLOCKS_DIR,
     OUTPUT_DIR,
-    DETECTED_IMAGE_DIR,
-    SCANNED_IMAGE_DIR,
-    JSON_DIR,
+    # DETECTED_IMAGE_DIR,
+    # SCANNED_IMAGE_DIR,
+    # JSON_DIR,
 ):
     d.mkdir(parents=True, exist_ok=True)
 # def classify_image_type(description_or_name: str) -> str:
@@ -124,6 +137,9 @@ class GameState(TypedDict):
     action_plan: Optional[Dict]
     temporary_node: Optional[Dict]
     
+# class GameState(TypedDict):
+#     image: str
+#     pseudo_node: Optional[Dict]
     
 # Refined SYSTEM_PROMPT with more explicit Scratch JSON rules, especially for variables
 SYSTEM_PROMPT = """
@@ -223,7 +239,7 @@ agent_json_resolver = create_react_agent(
     prompt=SYSTEM_PROMPT_JSON_CORRECTOR 
 )
 
-# Helper function to load the block catalog from a JSON file
+# # Helper function to load the block catalog from a JSON file
 # def _load_block_catalog(file_path: str) -> Dict:
 #     """Loads the Scratch block catalog from a specified JSON file."""
 #     try:
@@ -287,26 +303,8 @@ def find_block_in_all(opcode: str, all_catalogs: list[dict]) -> dict | None:
     return None
 
 
-
-# --- Global variable for the block catalog ---
 # --- Global variable for the block catalog ---
 ALL_SCRATCH_BLOCKS_CATALOG = {}
-# BLOCK_CATALOG_PATH = r"blocks\blocks.json" # Define the path to your JSON file
-# HAT_BLOCKS_PATH = r"blocks\hat_blocks.json" # Path to the hat blocks JSON file
-# STACK_BLOCKS_PATH = r"blocks\stack_blocks.json" # Path to the stack blocks JSON file
-# REPORTER_BLOCKS_PATH = r"blocks\reporter_blocks.json" # Path to the reporter blocks JSON file
-# BOOLEAN_BLOCKS_PATH = r"blocks\boolean_blocks.json" # Path to the boolean blocks JSON file
-# C_BLOCKS_PATH = r"blocks\c_blocks.json" # Path to the C blocks JSON file
-# CAP_BLOCKS_PATH = r"blocks\cap_blocks.json" # Path to the cap blocks JSON file
-
-# BLOCK_CATALOG_PATH = r"blocks/blocks.json" 
-# HAT_BLOCKS_PATH = r"blocks/hat_blocks.json" 
-# STACK_BLOCKS_PATH = r"blocks/stack_blocks.json" 
-# REPORTER_BLOCKS_PATH = r"blocks/reporter_blocks.json" 
-# BOOLEAN_BLOCKS_PATH = r"blocks/boolean_blocks.json" 
-# C_BLOCKS_PATH = r"blocks/c_blocks.json" 
-# CAP_BLOCKS_PATH = r"blocks/cap_blocks.json" 
-
 BLOCK_CATALOG_PATH = "blocks" # Define the path to your JSON file
 HAT_BLOCKS_PATH = "hat_blocks" # Path to the hat blocks JSON file
 STACK_BLOCKS_PATH = "stack_blocks" # Path to the stack blocks JSON file
@@ -315,15 +313,24 @@ BOOLEAN_BLOCKS_PATH = "boolean_blocks" # Path to the boolean blocks JSON file
 C_BLOCKS_PATH = "c_blocks" # Path to the C blocks JSON file
 CAP_BLOCKS_PATH = "cap_blocks" # Path to the cap blocks JSON file
 
+# BLOCK_CATALOG_PATH = BLOCKS_DIR / "blocks.json" 
+# HAT_BLOCKS_PATH = BLOCKS_DIR / "hat_blocks.json" 
+# STACK_BLOCKS_PATH = BLOCKS_DIR / "stack_blocks.json"
+# REPORTER_BLOCKS_PATH = BLOCKS_DIR / "reporter_blocks.json" 
+# BOOLEAN_BLOCKS_PATH = BLOCKS_DIR / "boolean_blocks.json" 
+# C_BLOCKS_PATH = BLOCKS_DIR / "c_blocks.json" 
+# CAP_BLOCKS_PATH = BLOCKS_DIR / "cap_blocks.json"
+
 # Load the block catalogs from their respective JSON files
 hat_block_data = _load_block_catalog(HAT_BLOCKS_PATH)
-# hat_description = hat_block_data["description"]
-hat_description = hat_block_data.get("description", "No description available")
+hat_description = hat_block_data["description"]
+#hat_description = hat_block_data.get("description", "No description available")
 # hat_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in hat_block_data["blocks"]])
 hat_opcodes_functionalities = "\n".join([
     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
     for block in hat_block_data.get("blocks", [])
 ]) if isinstance(hat_block_data.get("blocks"), list) else "    No blocks information available."
+hat_opcodes_functionalities = os.path.join(BLOCKS_DIR, "hat_blocks.txt")
 print("Hat blocks loaded successfully.", hat_description)
 
 boolean_block_data = _load_block_catalog(BOOLEAN_BLOCKS_PATH)
@@ -333,6 +340,7 @@ boolean_opcodes_functionalities = "\n".join([
     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
     for block in boolean_block_data.get("blocks", [])
 ]) if isinstance(boolean_block_data.get("blocks"), list) else "    No blocks information available."
+boolean_opcodes_functionalities = os.path.join(BLOCKS_DIR, "boolean_blocks.txt")
 
 c_block_data = _load_block_catalog(C_BLOCKS_PATH)
 c_description = c_block_data["description"]
@@ -341,6 +349,7 @@ c_opcodes_functionalities = "\n".join([
     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
     for block in c_block_data.get("blocks", [])
 ]) if isinstance(c_block_data.get("blocks"), list) else "    No blocks information available."
+c_opcodes_functionalities = os.path.join(BLOCKS_DIR, "c_blocks.txt")
 
 cap_block_data = _load_block_catalog(CAP_BLOCKS_PATH)
 cap_description = cap_block_data["description"]                                                                                                                                                                                                                                                                                                                                                                                                                                                      
@@ -349,6 +358,7 @@ cap_opcodes_functionalities = "\n".join([
     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
     for block in cap_block_data.get("blocks", [])
 ]) if isinstance(cap_block_data.get("blocks"), list) else "    No blocks information available."
+cap_opcodes_functionalities = os.path.join(BLOCKS_DIR, "cap_blocks.txt")
 
 reporter_block_data = _load_block_catalog(REPORTER_BLOCKS_PATH)
 reporter_description = reporter_block_data["description"]
@@ -357,6 +367,7 @@ reporter_opcodes_functionalities = "\n".join([
     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
     for block in reporter_block_data.get("blocks", [])
 ]) if isinstance(reporter_block_data.get("blocks"), list) else "    No blocks information available."
+reporter_opcodes_functionalities = os.path.join(BLOCKS_DIR, "reporter_blocks.txt")
 
 stack_block_data = _load_block_catalog(STACK_BLOCKS_PATH)
 stack_description = stack_block_data["description"]
@@ -365,6 +376,7 @@ stack_opcodes_functionalities = "\n".join([
     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
     for block in stack_block_data.get("blocks", [])
 ]) if isinstance(stack_block_data.get("blocks"), list) else "    No blocks information available."
+stack_opcodes_functionalities = os.path.join(BLOCKS_DIR, "stack_blocks.txt")
 
 # This makes ALL_SCRATCH_BLOCKS_CATALOG available globally
 ALL_SCRATCH_BLOCKS_CATALOG = _load_block_catalog(BLOCK_CATALOG_PATH)
@@ -435,6 +447,49 @@ def extract_json_from_llm_response(raw_response: str) -> dict:
         logger.error("Sanitized JSON still invalid:\n%s", json_string)
         raise
 
+def clean_base64_for_model(raw_b64):
+    """
+    Normalize input into a valid data:image/png;base64,<payload> string.
+
+    Accepts:
+      - a list of base64 strings → picks the first element
+      - a PIL Image instance       → encodes to PNG/base64
+      - a raw base64 string        → strips whitespace and data URI prefix
+    """
+    if not raw_b64:
+        return ""
+
+    # 1. If it’s a list, take its first element
+    if isinstance(raw_b64, list):
+        raw_b64 = raw_b64[0] if raw_b64 else ""
+        if not raw_b64:
+            return ""
+
+    # 2. If it’s a PIL Image, convert to base64
+    if isinstance(raw_b64, Image.Image):
+        buf = io.BytesIO()
+        raw_b64.save(buf, format="PNG")
+        raw_b64 = base64.b64encode(buf.getvalue()).decode()
+
+    # 3. At this point it must be a string
+    if not isinstance(raw_b64, str):
+        raise TypeError(f"Expected base64 string or PIL Image, got {type(raw_b64)}")
+
+    # 4. Strip any existing data URI prefix, whitespace, or newlines
+    clean_b64 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", raw_b64)
+    clean_b64 = clean_b64.replace("\n", "").replace("\r", "").strip()
+
+    # 5. Validate it’s proper base64
+    try:
+        base64.b64decode(clean_b64)
+    except Exception as e:
+        logger.error(f"Invalid Base64 passed to model: {e}")
+        raise
+
+    # 6. Return with the correct data URI prefix
+    return f"data:image/png;base64,{clean_b64}"
+
+
 # Node 1: Logic updating if any issue here
 def pseudo_generator_node(state: GameState):
     logger.info("--- Running plan_logic_aligner_node ---")
@@ -598,7 +653,8 @@ If you find any "Code-Blocks" then,
     image_input = {
         "type": "image_url",
         "image_url": {
-            "url": f"data:image/png;base64,{image}"
+            # "url": f"data:image/png;base64,{image}"
+            "url": clean_base64_for_model(image)
         }
     }
 
@@ -1458,86 +1514,86 @@ Example output:
     return state
 
 # Node 10:Function based block builder node
-# def overall_block_builder_node_2(state: dict):
-#     logger.info("--- Running OverallBlockBuilderNode ---")
-
-#     project_json = state["project_json"]
-#     targets = project_json["targets"]
-#     # --- Sprite and Stage Target Mapping ---
-#     sprite_map = {target["name"]: target for target in targets if not target["isStage"]}
-#     stage_target = next((target for target in targets if target["isStage"]), None)
-#     if stage_target:
-#         sprite_map[stage_target["name"]] = stage_target
-
-#     action_plan = state.get("action_plan", {})
-#     print("[Overall Action Plan received at the block generator]:", json.dumps(action_plan, indent=2))
-#     if not action_plan:
-#         logger.warning("No action plan found in state. Skipping OverallBlockBuilderNode.")
-#         return state
-
-#     # Initialize offsets for script placement on the Scratch canvas
-#     script_y_offset = {}
-#     script_x_offset_per_sprite = {name: 0 for name in sprite_map.keys()}
-
-#     # This handles potential variations in the action_plan structure.
-#     if action_plan.get("action_overall_flow", {}) == {}:
-#         plan_data = action_plan.items()
-#     else:
-#         plan_data = action_plan.get("action_overall_flow", {}).items()
-
-#     # --- Extract global project context for LLM ---
-#     all_sprite_names = list(sprite_map.keys())
-#     all_variable_names = {}
-#     all_list_names = {}
-#     all_broadcast_messages = {}
-
-#     for target in targets:
-#         for var_id, var_info in target.get("variables", {}).items():
-#             all_variable_names[var_info[0]] = var_id  # Store name -> ID mapping (e.g., "myVariable": "myVarId123")
-#         for list_id, list_info in target.get("lists", {}).items():
-#             all_list_names[list_info[0]] = list_id  # Store name -> ID mapping
-#         for broadcast_id, broadcast_name in target.get("broadcasts", {}).items():
-#             all_broadcast_messages[broadcast_name] = broadcast_id  # Store name -> ID mapping
-
-#     # --- Process each sprite's action plan ---
-#     for sprite_name, sprite_actions_data in plan_data:
-#         if sprite_name in sprite_map:
-#             current_sprite_target = sprite_map[sprite_name]
-#             if "blocks" not in current_sprite_target:
-#                 current_sprite_target["blocks"] = {}
-
-#             if sprite_name not in script_y_offset:
-#                 script_y_offset[sprite_name] = 0
-
-#             for plan_entry in sprite_actions_data.get("plans", []):
-#                 logic_sequence = str(plan_entry["logic"])
-#                 opcode_counts = plan_entry.get("opcode_counts", {})
-
-#                 try:
-#                     generated_blocks=block_builder(opcode_counts,logic_sequence)                
-#                     if "blocks" in generated_blocks and isinstance(generated_blocks["blocks"], dict):
-#                         logger.warning(f"LLM returned nested 'blocks' key for {sprite_name}. Unwrapping.")
-#                         generated_blocks = generated_blocks["blocks"]
-
-#                     # Update block positions for top-level script
-#                     for block_id, block_data in generated_blocks.items():
-#                         if block_data.get("topLevel"):
-#                             block_data["x"] = script_x_offset_per_sprite.get(sprite_name, 0)
-#                             block_data["y"] = script_y_offset[sprite_name]
-#                             script_y_offset[sprite_name] += 150 # Increment for next script
-
-#                     current_sprite_target["blocks"].update(generated_blocks)
-#                     print(f"[current_sprite_target block updated]: {current_sprite_target['blocks']}")
-#                     state["iteration_count"] = 0
-#                     logger.info(f"Action blocks added for sprite '{sprite_name}' by OverallBlockBuilderNode.")
-#                 except Exception as e:
-#                     logger.error(f"Error generating blocks for sprite '{sprite_name}': {e}")
+def overall_block_builder_node_2(state: dict):
+    logger.info("--- Running OverallBlockBuilderNode ---")
+
+    project_json = state["project_json"]
+    targets = project_json["targets"]
+    # --- Sprite and Stage Target Mapping ---
+    sprite_map = {target["name"]: target for target in targets if not target["isStage"]}
+    stage_target = next((target for target in targets if target["isStage"]), None)
+    if stage_target:
+        sprite_map[stage_target["name"]] = stage_target
+
+    action_plan = state.get("action_plan", {})
+    print("[Overall Action Plan received at the block generator]:", json.dumps(action_plan, indent=2))
+    if not action_plan:
+        logger.warning("No action plan found in state. Skipping OverallBlockBuilderNode.")
+        return state
+
+    # Initialize offsets for script placement on the Scratch canvas
+    script_y_offset = {}
+    script_x_offset_per_sprite = {name: 0 for name in sprite_map.keys()}
+
+    # This handles potential variations in the action_plan structure.
+    if action_plan.get("action_overall_flow", {}) == {}:
+        plan_data = action_plan.items()
+    else:
+        plan_data = action_plan.get("action_overall_flow", {}).items()
+
+    # --- Extract global project context for LLM ---
+    all_sprite_names = list(sprite_map.keys())
+    all_variable_names = {}
+    all_list_names = {}
+    all_broadcast_messages = {}
+
+    for target in targets:
+        for var_id, var_info in target.get("variables", {}).items():
+            all_variable_names[var_info[0]] = var_id  # Store name -> ID mapping (e.g., "myVariable": "myVarId123")
+        for list_id, list_info in target.get("lists", {}).items():
+            all_list_names[list_info[0]] = list_id  # Store name -> ID mapping
+        for broadcast_id, broadcast_name in target.get("broadcasts", {}).items():
+            all_broadcast_messages[broadcast_name] = broadcast_id  # Store name -> ID mapping
+
+    # --- Process each sprite's action plan ---
+    for sprite_name, sprite_actions_data in plan_data:
+        if sprite_name in sprite_map:
+            current_sprite_target = sprite_map[sprite_name]
+            if "blocks" not in current_sprite_target:
+                current_sprite_target["blocks"] = {}
+
+            if sprite_name not in script_y_offset:
+                script_y_offset[sprite_name] = 0
+
+            for plan_entry in sprite_actions_data.get("plans", []):
+                logic_sequence = str(plan_entry["logic"])
+                opcode_counts = plan_entry.get("opcode_counts", {})
+
+                try:
+                    generated_blocks=block_builder(opcode_counts,logic_sequence)                
+                    if "blocks" in generated_blocks and isinstance(generated_blocks["blocks"], dict):
+                        logger.warning(f"LLM returned nested 'blocks' key for {sprite_name}. Unwrapping.")
+                        generated_blocks = generated_blocks["blocks"]
+
+                    # Update block positions for top-level script
+                    for block_id, block_data in generated_blocks.items():
+                        if block_data.get("topLevel"):
+                            block_data["x"] = script_x_offset_per_sprite.get(sprite_name, 0)
+                            block_data["y"] = script_y_offset[sprite_name]
+                            script_y_offset[sprite_name] += 150 # Increment for next script
+
+                    current_sprite_target["blocks"].update(generated_blocks)
+                    print(f"[current_sprite_target block updated]: {current_sprite_target['blocks']}")
+                    state["iteration_count"] = 0
+                    logger.info(f"Action blocks added for sprite '{sprite_name}' by OverallBlockBuilderNode.")
+                except Exception as e:
+                    logger.error(f"Error generating blocks for sprite '{sprite_name}': {e}")
                     
-#     state["project_json"] = project_json
-#     # with open("debug_state.json", "w", encoding="utf-8") as f:
-#     #     json.dump(state, f, indent=2, ensure_ascii=False)
+    state["project_json"] = project_json
+    # with open("debug_state.json", "w", encoding="utf-8") as f:
+    #     json.dump(state, f, indent=2, ensure_ascii=False)
     
-#     return state
+    return state
 # Node 10:Function based block builder node
 def overall_block_builder_node_2(state: dict):
     logger.info("--- Running OverallBlockBuilderNode ---")
@@ -1641,46 +1697,273 @@ def variable_adder_node(state: GameState):
         raise
 
 
-scratch_keywords = [
-                    "move", "turn", "wait", "repeat", "if", "else", "broadcast",
-                    "glide", "change", "forever", "when", "switch",
-                    "next costume", "set", "show", "hide", "play sound",
-                    "go to", "x position", "y position", "think", "say",
-                    "variable", "stop", "clone",
-                    "touching", "sensing", "pen", "clear","Scratch","Code","scratch blocks"
-                ]
+# scratch_keywords = [
+#                     "move", "turn", "wait", "repeat", "if", "else", "broadcast",
+#                     "glide", "change", "forever", "when", "switch",
+#                     "next costume", "set", "show", "hide", "play sound",
+#                     "go to", "x position", "y position", "think", "say",
+#                     "variable", "stop", "clone",
+#                     "touching", "sensing", "pen", "clear","Scratch","Code","scratch blocks"
+#                 ]
+
+# Node 6: Logic updating if any issue here
+# def plan_logic_aligner_node(state: GameState):
+#     logger.info("--- Running plan_logic_aligner_node ---")
+
+#     image = state.get("image", "")
+    
+#     refinement_prompt = f"""
+#         You are an expert in Scratch 3.0 game development, specializing in understanding block relationships (stacked, nested).
+#         "Analyze the Scratch code-block image and generate Pseudo-Code for what this logic appears to be doing."
+#         From Image, you also have to detect a value of Key given in Text form "Script for: ". Below is the example
+#         Example: "Script for: Bear", "Script for:" is a key and "Bear" is value.
+#         --- Scratch 3.0 Block Reference ---
+#             ### Hat Blocks
+#             Description: {hat_description}
+#             Blocks:
+#             {hat_opcodes_functionalities}
+        
+#             ### Boolean Blocks
+#             Description: {boolean_description}
+#             Blocks:
+#             {boolean_opcodes_functionalities}
+        
+#             ### C Blocks
+#             Description: {c_description}
+#             Blocks:
+#             {c_opcodes_functionalities}
+        
+#             ### Cap Blocks
+#             Description: {cap_description}
+#             Blocks:
+#             {cap_opcodes_functionalities}
+        
+#             ### Reporter Blocks
+#             Description: {reporter_description}
+#             Blocks:
+#             {reporter_opcodes_functionalities}
+        
+#             ### Stack Blocks
+#             Description: {stack_description}
+#             Blocks:
+#             {stack_opcodes_functionalities}
+#         -----------------------------------
+        
+#         Your task is to:
+#         If you don't find any "Code-Blocks" then,
+#             **Don't generate Pseudo Code, and pass the message "No Code-blocks" find...
+#         If you find any "Code-Blocks" then, 
+#         1. **Refine the 'logic'**: Make it precise, accurate, and fully aligned with the Game Description. Use Scratch‑consistent verbs and phrasing. **Do NOT** use raw double‑quotes inside the logic string.
+        
+#         2. **Structural requirements**:
+#         - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
+#         - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
+#         - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
+#         - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
+#         - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
+#         - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
+#         - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
+#         - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
+#             ```
+#             (([ballSpeed v]) * (1.1))
+#             ```
+#         - **Every hat block script must end** with a final `end` on its own line.
+        
+#         3. **Pseudo‑code formatting**:
+#         - Represent each block or nested block on its own line.
+#         - Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).
+#         - No comments or explanatory text—just the block sequence.
+#         - a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.
+        
+#         4. **Logic content**:
+#         - Build clear flow for mechanics (movement, jumping, flying, scoring, collisions).
+#         - Match each action closely to a Scratch block or tight sequence.
+#         - Do **NOT** include any justification or comments—only the raw logic.
+        
+#         5. **Examples for reference**:  
+#         **Correct** pattern for a simple start script:
+#         ```
+#         when green flag clicked
+#         switch backdrop to [blue sky v]
+#         set [score v] to (0)
+#         show variable [score v]
+#         broadcast [Game Start v]
+#         end
+#         ```
+#         **Correct** pattern for updating the high score variable handling:
+#         ```
+#         when I receive [Game Over v]
+#         if <((score)) > (([High Score v]))> then
+#         set [High Score v] to ([score v])
+#         end
+#         switch backdrop to [Game Over v]
+#         end
+#         ```
+#         **Correct** pattern for level up and increase difficulty use:
+#         ```
+#         when I receive [Level Up v]
+#         change [level v] by (1)
+#         set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
+#         end
+#         ```
+#         **Correct** pattern for jumping mechanics use:
+#         ```
+#         when [space v] key pressed
+#         if <((y position)) = (-100)> then
+#         repeat (5)
+#         change y by (100)
+#         wait (0.1) seconds
+#         change y by (-100)
+#         wait (0.1) seconds
+#         end
+#         end
+#         end
+#         ```
+#         **Correct** pattern for continuos moving objects use:
+#         ```
+#         when green flag clicked
+#         go to x: (240) y: (-100)
+#         set [speed v] to (-5)
+#         show variable [speed v]
+#         forever
+#         change x by ([speed v])
+#         if <((x position)) < (-240)> then
+#         go to x: (240) y: (-100)
+#         end
+#         end
+#         end
+#         ```
+#         **Correct** pattern for continuos moving objects use:
+#         ```
+#         when green flag clicked
+#         go to x: (240) y: (-100)
+#         set [speed v] to (-5)
+#         show variable [speed v]
+#         forever
+#         change x by ([speed v])
+#         if <((x position)) < (-240)> then
+#         go to x: (240) y: (-100)
+#         end
+#         end
+#         end
+#         ```
+#         6. **Donot** add any explaination of logic or comments to justify or explain just put the logic content in the json.
+#         7. **Output**:  
+#         Return **only** a JSON object, using double quotes everywhere:
+#         ```json
+#         {{
+#         "refined_logic":{{
+#             "name_variable": 'Value of "Sript for: "',
+#             "pseudocode":"…your fully‑formatted pseudo‑code here…",
+#              }}
+#         }}
+#         ```
+#         """
+#     image_input = {
+#         "type": "image_url",
+#         "image_url": {
+#             "url": f"data:image/png;base64,{image}"
+#         }
+#     }
+
+#     content = [
+#         {"type": "text", "text": refinement_prompt},
+#         image_input
+#     ]
+
+#     try:
+#         # Invoke the main agent for logic refinement and relationship identification
+#         response = agent.invoke({"messages": [{"role": "user", "content": content}]})
+#         llm_output_raw = response["messages"][-1].content.strip()
+
+#         parsed_llm_output = extract_json_from_llm_response(llm_output_raw)
+        
+#         # result = parsed_llm_output
+#         # Extract needed values directly
+#         logic_data = parsed_llm_output.get("refined_logic", {})
+#         name_variable = logic_data.get("name_variable", "Unknown")
+#         pseudocode = logic_data.get("pseudocode", "No logic extracted")
+        
+#         result = {"pseudo_node": {
+#             "name_variable": name_variable,
+#             "pseudocode": pseudocode
+#         }}
+        
+#         print(f"result:\n\n {result}")
+#         return result
+#     except Exception as e:
+#         logger.error(f"❌ plan_logic_aligner_node failed: {str(e)}")
+#         return {"error": str(e)}
+#     except json.JSONDecodeError as error_json:
+#         # If JSON parsing fails, use the json resolver agent
+#         correction_prompt = (
+#             "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
+#             "It must be a JSON object with `refined_logic` (string) and `block_relationships` (array of objects).\n"
+#             f"- **Error Details**: {error_json}\n\n"
+#             "**Strict Instructions for your response:**\n"
+#             "1. **ONLY** output the corrected JSON. Do not include any other text or explanations.\n"
+#             "2. Ensure all keys and string values are enclosed in **double quotes**. Escape internal quotes (`\\`).\n"
+#             "3. No trailing commas. Correct nesting.\n\n"
+#             "Here is the problematic JSON string to correct:\n"
+#             f"```json\n{llm_output_raw}\n```\n"
+#             "Corrected JSON:\n"
+#         )
+#         try:
+#             correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
+#             corrected_output = extract_json_from_llm_response(correction_response["messages"][-1].content)
+            
+#             result = {
+#                 #"image_path": image_path,
+#                 "pseudo_code": corrected_output
+#             }
+            
+#             return result
+        
+#         except Exception as e_corr:
+#             logger.error(f"Failed to correct JSON output for even after retry: {e_corr}")
 
 #def extract_images_from_pdf(pdf_path: Path, json_base_dir: Path, image_base_dir: Path):
 #def extract_images_from_pdf(pdf_path: Path, json_base_dir: Path):
-def extract_images_from_pdf(pdf_path: Path):
+
+# Prepare manipulated sprite JSON structure
+manipulated_json = {}
+img_elements = []
+# { changes: "pdf_stream" in place of "pdf_path"
+def extract_images_from_pdf(pdf_stream: io.BytesIO):
     ''' Extract images from PDF and generate structured sprite JSON '''
     try:
-        pdf_path = Path(pdf_path)
-        pdf_filename = pdf_path.stem               # e.g., "scratch_crab"
-        pdf_dir_path = str(pdf_path.parent).replace("/", "\\")
-        print("-------------------------------pdf_filename-------------------------------",pdf_filename)
-        print("-------------------------------pdf_dir_path-------------------------------",pdf_dir_path)
-        # Create subfolders under the provided base directories
-        # This will create paths like:
-        # /app/detected_images/pdf_filename/
-        # /app/json_data/pdf_filename/
-        extracted_image_subdir = DETECTED_IMAGE_DIR / pdf_filename
-        json_subdir = JSON_DIR / pdf_filename
-        extracted_image_subdir.mkdir(parents=True, exist_ok=True)
-        json_subdir.mkdir(parents=True, exist_ok=True)
-        print("-------------------------------extracted_image_subdir-------------------------------",extracted_image_subdir)
-        print("-------------------------------json_subdir-------------------------------",json_subdir)
-        # Output paths (now using Path objects directly)
-        output_json_path = json_subdir / "extracted.json"
-        final_json_path = json_subdir / "extracted_sprites.json" # Path to extracted_sprites.json
-        final_json_path_2 = json_subdir / "extracted_sprites_2.json"
-        print("-------------------------------output_json_path-------------------------------",output_json_path)
-        print("-------------------------------final_json_path-------------------------------",final_json_path)
-        print("-------------------------------final_json_path_2-------------------------------",final_json_path_2)
+        # {
+        # pdf_path = Path(pdf_path)
+        # pdf_filename = pdf_path.stem               # e.g., "scratch_crab"
+        # pdf_dir_path = str(pdf_path.parent).replace("/", "\\")
+        # print("-------------------------------pdf_filename-------------------------------",pdf_filename)
+        # print("-------------------------------pdf_dir_path-------------------------------",pdf_dir_path)
+
+        if isinstance(pdf_stream, io.BytesIO):
+            # use a random ID since there's no filename
+            pdf_id = uuid.uuid4().hex    
+        else:
+            pdf_id = os.path.splitext(os.path.basename(pdf_stream))[0]
+            
+        # extracted_image_subdir = DETECTED_IMAGE_DIR / pdf_filename
+        # json_subdir = JSON_DIR / pdf_filename
+        # extracted_image_subdir.mkdir(parents=True, exist_ok=True)
+        # json_subdir.mkdir(parents=True, exist_ok=True)
+        # print("-------------------------------extracted_image_subdir-------------------------------",extracted_image_subdir)
+        # print("-------------------------------json_subdir-------------------------------",json_subdir)
+        # # Output paths (now using Path objects directly)
+        # output_json_path = json_subdir / "extracted.json"
+        # final_json_path = json_subdir / "extracted_sprites.json" # Path to extracted_sprites.json
+        # final_json_path_2 = json_subdir / "extracted_sprites_2.json"
+        # print("-------------------------------output_json_path-------------------------------",output_json_path)
+        # print("-------------------------------final_json_path-------------------------------",final_json_path)
+        # print("-------------------------------final_json_path_2-------------------------------",final_json_path_2)
         
+        # }
         try:
             elements = partition_pdf(
-                filename=str(pdf_path), # partition_pdf might expect a string
+                # filename=str(pdf_path), # partition_pdf might expect a string
+                file=pdf_stream, # 'file=', inplace of 'filename'
                 strategy="hi_res",
                 extract_image_block_types=["Image"],
                 hi_res_model_name="yolox",
@@ -1691,155 +1974,44 @@ def extract_images_from_pdf(pdf_path: Path):
             raise RuntimeError(
                 f"❌ Failed to extract images from PDF: {str(e)}")
 
-        try:
-            with open(output_json_path, "w") as f:
-                json.dump([element.to_dict()
-                          for element in elements], f, indent=4)
-        except Exception as e:
-            raise RuntimeError(f"❌ Failed to write extracted.json: {str(e)}")
-
-        try:
-            # Display extracted images
-            with open(output_json_path, 'r') as file:
-                file_elements = json.load(file)
-        except Exception as e:
-            raise RuntimeError(f"❌ Failed to read extracted.json: {str(e)}")
-
-        # Prepare manipulated sprite JSON structure
-        manipulated_json = {}
+        file_elements = [element.to_dict() for element in elements]
+
+        #{
+        # try:
+        #     with open(output_json_path, "w") as f:
+        #         json.dump([element.to_dict()
+        #                   for element in elements], f, indent=4)
+        # except Exception as e:
+        #     raise RuntimeError(f"❌ Failed to write extracted.json: {str(e)}")
+
+        # try:
+        #     # Display extracted images
+        #     with open(output_json_path, 'r') as file:
+        #         file_elements = json.load(file)
+        # except Exception as e:
+        #     raise RuntimeError(f"❌ Failed to read extracted.json: {str(e)}") 
+        # }
 
-        # SET A SYSTEM PROMPT
-        system_prompt = """
-            You are an expert in visual scene understanding.
-            Your Job is to analyze an image and respond acoording if asked for name give simple name by analyzing it and if ask for descrption generate a short description covering its elements.
+        sprite_count = 1
+        for el in file_elements:
+            img_b64 = el["metadata"].get("image_base64")
+            if not img_b64:
+                continue 
             
-            Guidelines:
-            - Focus only the images given in Square Shape.
-            - Don't Consider Blank areas in Image as.
-            - Don't include generic summary or explanation outside the fields.
-            Return only string.
-            """
-        agent = create_react_agent(
-            model=llm,
-            tools=[],
-            prompt=system_prompt
-        )
-
-        # If JSON already exists, load it and find the next available Sprite number
-        if final_json_path.exists(): # Use Path.exists()
-            with open(final_json_path, "r") as existing_file:
-                manipulated = json.load(existing_file)
-            # Determine the next available index (e.g., Sprite 4 if 1–3 already exist)
-            existing_keys = [int(k.replace("Sprite ", ""))
-                             for k in manipulated.keys()]
-            start_count = max(existing_keys, default=0) + 1
-        else:
-            start_count = 1
-
-        sprite_count = start_count
-        for i, element in enumerate(file_elements):
-            if "image_base64" in element["metadata"]:
-                try:
-                    image_data = base64.b64decode(
-                        element["metadata"]["image_base64"])
-                    print(f"\n ------------------------------image_data: {image_data}")
-                    image = Image.open(BytesIO(image_data)).convert("RGB") # Use BytesIO here
-                    
-                    image = upscale_image(image, scale=2)
-                    # image.show(title=f"Extracted Image {i+1}")
-                    
-                    # MODIFIED: Store image directly to BytesIO to avoid saving to disk if not needed
-                    # and then converting back to base64.
-                    img_buffer = BytesIO()
-                    image.save(img_buffer, format="PNG")
-                    img_bytes = img_buffer.getvalue()
-                    img_base64 = base64.b64encode(img_bytes).decode("utf-8")
-                    print(f"\n------------------------------------------------Image_Base64: {img_base64}")
-                    # Optionally save image to disk if desired for debugging/permanent storage
-                    image_path = extracted_image_subdir / f"Sprite_{i+1}.png"
-                    image.save(image_path)
-                    
-                    prompt_combined = """
-                    Analyze this image and return JSON with keys:# modify prompt for "name", if it detects "code-blocks only then give name as 'scratch-block'"
-                    {
-                    "name": "<short name or 'scratch blocks'>" ,
-                    "description": "<short description>"
-                    }
-                    Guidelines:
-                    - If image contains logical/code blocks from Scratch (e.g., move, turn, repeat, when clicked, etc.), use 'scratch-block' as the name.
-                    - If image is a character, object, or backdrop, give an appropriate descriptive name instead.
-                    - Avoid generic names like 'image1' or 'picture'.
-                    - Keep the response strictly in JSON format.
-                    """
-                    
-                    content = [
-                        {"type": "text", "text": prompt_combined},
-                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"}}
-                    ]
-                    
-                    response = agent.invoke({"messages": [{"role": "user", "content": content}]})
-                    
-                    # Ensure response is handled correctly, it might be a string that needs json.loads
-                    try:
-                        # Assuming the agent returns a dictionary with 'messages' key,
-                        # and the last message's content is the JSON string.
-                        response_content_str = response.get("messages", [])[-1].content
-                        result_json = json.loads(response_content_str)
-                    except (json.JSONDecodeError, IndexError, AttributeError) as e:
-                        logger.error(f"⚠️ Failed to parse agent response as JSON: {e}. Response was: {response}", exc_info=True)
-                        result_json = {} # Default to empty dict if parsing fails
-
-                    try:
-                        name = result_json.get("name", "").strip()
-                        description = result_json.get("description", "").strip()
-                    except Exception as e:
-                        logger.error(f"⚠️ Failed to extract name/description from result_json: {str(e)}", exc_info=True)
-                        name = "unknown"
-                        description = "unknown"                    
-
-                    manipulated_json[f"Sprite {sprite_count}"] = {
-                        "name": name,
-                        "base64": element["metadata"]["image_base64"],
-                        "file-path": pdf_dir_path,
-                        "description": description
-                    }
-                    print(f"\n ------------------elemente: {element['metadata']['image_base64']}")
-                    print(f"\n ------------------pdf_dir_path: {pdf_dir_path}")
-                    sprite_count += 1
-                    print(f"\n===================manipulated JSON: {manipulated_json}")
-                except Exception as e:
-                    logger.error(f"⚠️ Error processing Sprite {i+1}: {str(e)}", exc_info=True)
-                    
-        # Save manipulated JSON
-        with open(final_json_path, "w") as sprite_file:
-            json.dump(manipulated_json, sprite_file, indent=4)
-        
-        def is_code_block(name: str) -> bool:
-            for kw in scratch_keywords:
-                if kw.lower() in name.lower():
-                    return True
-            return False
-
-        # Filter out code block images
-        filtered_sprites = {}
-        for key, value in manipulated_json.items():
-            sprite_name = value.get("name", "")
-            if not is_code_block(sprite_name):
-                filtered_sprites[key] = value
-            else:
-                logger.info(f"🛑 Excluded code block-like image: {key}")
-
-        # Overwrite with filtered content
-        with open(final_json_path_2, "w") as sprite_file:
-            json.dump(filtered_sprites, sprite_file, indent=4)
-        
-        # MODIFIED RETURN VALUE: Return the Path to the primary extracted_sprites.json file
-        # and the directory where it's located.
-        return final_json_path, json_subdir # Return the file path and its parent directory
+            manipulated_json[f"Sprite {sprite_count}"] = {
+                # "id":auto_id,
+                # "name": name,
+                "base64": el["metadata"]["image_base64"],
+                "file-path": pdf_id,
+                # "description": description
+            }
+            sprite_count += 1
+        return manipulated_json
     except Exception as e:
         raise RuntimeError(f"❌ Error in extract_images_from_pdf: {str(e)}")
 
-def similarity_matching(input_json_path: str, project_folder: str) -> str:
+# def similarity_matching(input_json_path: str, project_folder: str) -> str:
+def similarity_matching(sprites_data: str, project_folder: str) -> str:
     logger.info("🔍 Running similarity matching…")
     os.makedirs(project_folder, exist_ok=True)
 
@@ -1847,6 +2019,7 @@ def similarity_matching(input_json_path: str, project_folder: str) -> str:
     # CHANGED: define normalized base-paths so startswith() checks work
     backdrop_base_path = os.path.normpath(str(BACKDROP_DIR))
     sprite_base_path   = os.path.normpath(str(SPRITE_DIR))
+    code_blocks_path = os.path.normpath(str(CODE_BLOCKS_DIR))
     # ----------------------------------------
 
     project_json_path = os.path.join(project_folder, "project.json")
@@ -1854,15 +2027,23 @@ def similarity_matching(input_json_path: str, project_folder: str) -> str:
     # ==============================
     #    READ SPRITE METADATA
     # ==============================
-    with open(input_json_path, 'r') as f:
-        sprites_data = json.load(f)
+    # with open(input_json_path, 'r') as f:
+    #     sprites_data = json.load(f)
 
-    sprite_ids, texts, sprite_base64 = [], [], []
+    sprite_ids, sprite_base64 = [], []
     for sid, sprite in sprites_data.items():
         sprite_ids.append(sid)
-        texts.append("This is " + sprite.get("description", sprite.get("name", "")))
+        # texts.append("This is " + sprite.get("description", sprite.get("name", "")))
         sprite_base64.append(sprite["base64"])
 
+    sprite_images_bytes = []
+    for b64 in sprite_base64:
+        img = Image.open(BytesIO(base64.b64decode(b64.split(",")[-1]))).convert("RGB")
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        buffer.seek(0)
+        sprite_images_bytes.append(buffer)
+    
     # =========================================
     #  Build the list of all candidate images
     # =========================================
@@ -1882,6 +2063,13 @@ def similarity_matching(input_json_path: str, project_folder: str) -> str:
         SPRITE_DIR   / "Centaur.sprite3" / "2373556e776cad3ba4d6ee04fc34550b.png",
         SPRITE_DIR   / "Crab.sprite3"   / "bear_element.png",
         SPRITE_DIR   / "Soccer Ball.sprite3" / "cat_football.png",
+
+        CODE_BLOCKS_DIR  / "script1.jpg",
+        CODE_BLOCKS_DIR  / "script2.jpg",
+        CODE_BLOCKS_DIR  / "script3.jpg",
+        CODE_BLOCKS_DIR  / "script4.jpg",
+        CODE_BLOCKS_DIR  / "script5.jpg",
+        CODE_BLOCKS_DIR  / "script6.jpg"
     ]
     folder_image_paths = [os.path.normpath(str(p)) for p in folder_image_paths]
     # =========================================
@@ -1891,24 +2079,31 @@ def similarity_matching(input_json_path: str, project_folder: str) -> str:
     # -----------------------------------------
     with open(f"{BLOCKS_DIR}/embeddings.json", "r") as f:
         embedding_json = json.load(f)
-    img_matrix = np.array([img["embeddings"] for img in embedding_json])
 
     # =========================================
     #  Decode & embed each sprite image
     # =========================================
-    sprite_features = []
-    for b64 in sprite_base64:
-        if "," in b64:
-            b64 = b64.split(",", 1)[1]
-        img_bytes = base64.b64decode(b64)
-        pil_img = Image.open(BytesIO(img_bytes)).convert("RGB")
-        buf = BytesIO()
-        pil_img.save(buf, format="PNG")
-        buf.seek(0)
-        feats = clip_embd.embed_image([buf])[0]
-        sprite_features.append(feats)
+    # sprite_features = []
+    # for b64 in sprite_base64:
+    #     if "," in b64:
+    #         b64 = b64.split(",", 1)[1]
+            
+    #     img_bytes = base64.b64decode(b64)
+    #     pil_img = Image.open(BytesIO(img_bytes)).convert("RGB")
+    #     buf = BytesIO()
+    #     pil_img.save(buf, format="PNG")
+    #     buf.seek(0)
+    #     feats = clip_embd.embed_image([buf])[0]
+    #     sprite_features.append(feats)
+
+    # ============================== #
+    #      EMBED SPRITE IMAGES       #
+    # ============================== #
+    sprite_features = clip_embd.embed_image(sprite_images_bytes)
+    
     sprite_matrix = np.vstack(sprite_features)
-
+    img_matrix = np.array([img["embeddings"] for img in embedding_json])
+    
     # =========================================
     #  Compute similarities & pick best match
     # =========================================
@@ -2002,6 +2197,7 @@ def similarity_matching(input_json_path: str, project_folder: str) -> str:
         else:
             logger.warning(f"No project.json in {matched_folder}")
 
+
     # =========================================
     #  Merge into final Scratch project.json
     # =========================================
@@ -2179,6 +2375,29 @@ def similarity_matching(input_json_path: str, project_folder: str) -> str:
     # # logger.info(f"🎉 Final project saved: {project_json_path}")
     # return project_json_path
 
+# def convert_bytes_to_image(pdf_bytes: bytes, dpi: int):
+#     images = convert_from_bytes(pdf_bytes, dpi=dpi, poppler_path=poppler_path)
+#     # Save each page to an in-memory BytesIO and return a list of BytesIOs
+#     buffers = []
+#     for img in images:
+#         buf = BytesIO()
+#         img.save(buf, format="PNG")
+#         buf.seek(0)
+#         buffers.append(buf)
+#     return buffers
+
+def convert_pdf_stream_to_images(pdf_stream: io.BytesIO, dpi=300):
+    # Ensure we are at the start of the stream
+    pdf_stream.seek(0)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_pdf:
+        tmp_pdf.write(pdf_stream.read())
+        tmp_pdf_path = tmp_pdf.name
+    
+    # Now use convert_from_path on the temp file
+    images = convert_from_path(tmp_pdf_path, dpi=dpi)
+    return images
+
 def delay_for_tpm_node(state: GameState):
     logger.info("--- Running DelayForTPMNode ---")
     time.sleep(60)  # Adjust the delay as needed
@@ -2229,7 +2448,8 @@ def upscale_image(image: Image.Image, scale: int = 2) -> Image.Image:
     except Exception as e:
         logger.error(f"❌ Error during image upscaling: {str(e)}")
         return image 
-        
+
+@log_execution_time
 def create_sb3_archive(project_folder, project_id):
     """
     Zips the project folder and renames it to an .sb3 file.
@@ -2269,19 +2489,22 @@ def create_sb3_archive(project_folder, project_id):
             os.remove(sb3_path)
         return sb3_path
 
-def save_pdf_to_generated_dir(pdf_path: str, project_id: str) -> str:
+#{ changes -> pdf_stream replacement of pdf_path
+# def save_pdf_to_generated_dir(pdf_path: str, project_id: str) -> str:
+def save_pdf_to_generated_dir(pdf_stream: io.BytesIO, project_id: str) -> str:
     """
-    Copies the PDF at `pdf_path` into GEN_PROJECT_DIR/project_id/,
+    Copies the PDF at `pdf_stream` into GEN_PROJECT_DIR/project_id/,
     renaming it to <project_id>.pdf.
 
     Args:
-        pdf_path (str):   Any existing path to a PDF file.
+        pdf_stream (io.BytesIO):   Any existing stream to a PDF file.
         project_id (str): Your unique project identifier.
 
     Returns:
         str: Path to the copied PDF in the generated directory,
              or None if something went wrong.
-    """
+    """ 
+    # }
     try:
         # 1) Build the destination directory and base filename
         output_dir = GEN_PROJECT_DIR / project_id
@@ -2292,9 +2515,16 @@ def save_pdf_to_generated_dir(pdf_path: str, project_id: str) -> str:
         target_pdf = output_dir / f"{project_id}.pdf"
         print(f"\n--------------------------------target_pdf {target_pdf}")
         # 3) Copy the PDF
-        shutil.copy2(pdf_path, target_pdf)
-        print(f"Copied PDF from {pdf_path} → {target_pdf}")
-        logger.info(f"Copied PDF from {pdf_path} → {target_pdf}")
+        # {
+        # shutil.copy2(pdf_path, target_pdf)
+        if isinstance(pdf_stream, io.BytesIO):
+            with open(target_pdf, "wb") as f:
+                f.write(pdf_stream.getbuffer())
+        else:
+            shutil.copy2(pdf_stream, target_pdf)
+        print(f"Copied PDF from {pdf_stream} → {target_pdf}")
+        logger.info(f"Copied PDF from {pdf_stream} → {target_pdf}") 
+        # }
         
 
         return str(target_pdf)
@@ -2355,22 +2585,40 @@ def process_pdf():
         #           Create empty json in project_{random_id} folder                   #
         # =========================================================================== #
         #os.makedirs(project_folder, exist_ok=True)
-        
+    
+        # {
         # Save the uploaded PDF temporarily
-        filename = secure_filename(pdf_file.filename)
-        temp_dir = tempfile.mkdtemp()
-        saved_pdf_path = os.path.join(temp_dir, filename)
-        pdf_file.save(saved_pdf_path)
-        pdf_doc = saved_pdf_path
-        pdf= save_pdf_to_generated_dir(saved_pdf_path, project_id) 
+        # filename = secure_filename(pdf_file.filename)
+        # temp_dir = tempfile.mkdtemp()
+        # saved_pdf_path = os.path.join(temp_dir, filename)
+        # pdf_file.save(saved_pdf_path)
+        # pdf_doc = saved_pdf_path
+        
+        pdf_bytes = pdf_file.read()
+        pdf_stream = io.BytesIO(pdf_bytes)
+        logger.info(f"Saved uploaded PDF to: {pdf_stream}")
+
+        # pdf= save_pdf_to_generated_dir(saved_pdf_path, project_id)
+        start_time = time.time()
+        pdf= save_pdf_to_generated_dir(pdf_stream, project_id)
         # logger.info(f"Created project folder: {project_folder}")
-        logger.info(f"Saved uploaded PDF to: {saved_pdf_path}")
+        # logger.info(f"Saved uploaded PDF to: {saved_pdf_path}")
         logger.info(f"Saved uploaded PDF to: {pdf_file}: {pdf}")
-        print("--------------------------------pdf_file_path---------------------",pdf_file,saved_pdf_path)
+        print("--------------------------------pdf_file_path---------------------",pdf_file,pdf_stream)
+        total_time = time.time() - start_time
+        print(f"-----------------------------Execution Time save_pdf_to_generated_dir() : {total_time}-----------------------------\n")
+        # }
+
+        # {
         # Extract & process
-        # output_path, result = extract_images_from_pdf(saved_pdf_path, json_path)
-        output_path, result = extract_images_from_pdf(saved_pdf_path)
-        print(" --------------------------------------- zip_path_str ---------------------------------------", output_path, result)
+        # output_path, result = extract_images_from_pdf(saved_pdf_path)
+        start_time = time.time()
+        output_path = extract_images_from_pdf(pdf_stream)
+        print(" --------------------------------------- zip_path_str ---------------------------------------", output_path) 
+        total_time = time.time() - start_time
+        print(f"-----------------------------Execution Time extract_images_from_pdf() : {total_time}-----------------------------\n")
+        # }
+        
         # Check extracted_sprites.json for "scratch block" in any 'name'
         # extracted_dir = os.path.join(JSON_DIR, os.path.splitext(filename)[0])
         # extracted_sprites_json = os.path.join(extracted_dir, "extracted_sprites.json")
@@ -2380,14 +2628,16 @@ def process_pdf():
 
         # with open(extracted_sprites_json, 'r') as f:
         #     sprite_data = json.load(f)
-
-        # project_output = similarity_matching(output_path, project_folder)
-        # logger.info("Received request to process PDF.")
+        start_time = time.time()
+        project_output = similarity_matching(output_path, project_folder)
+        logger.info("Received request to process PDF.")
+        total_time = time.time() - start_time
+        print(f"-----------------------------Execution Time similarity_matching() : {total_time}-----------------------------\n")
         
-        # with open(project_output, 'r') as f:
-        #     project_skeleton = json.load(f)
+        with open(project_output, 'r') as f:
+            project_skeleton = json.load(f)
             
-        # images = convert_from_path(saved_pdf_path, dpi=300)  
+        # images = convert_from_path(pdf_stream, dpi=300)  
         # print(type)
         # page = images[0]
         # # img_base64 = base64.b64encode(images).decode("utf-8") 
@@ -2396,31 +2646,39 @@ def process_pdf():
         # img_bytes = buf.getvalue()
         # img_b64 = base64.b64encode(img_bytes).decode("utf-8")
         #image_paths = await convert_pdf_to_images_async(saved_pdf_path)
-        
+
+        # images = convert_bytes_to_image(pdf_stream, dpi=250)
+        # print("PDF converted to images:", images)
+
+        if isinstance(pdf_stream, io.BytesIO):
+            images = convert_pdf_stream_to_images(pdf_stream, dpi=300)
+        else:
+            images = convert_from_path(pdf_stream, dpi=300)
+
         #updating logic here [Dev Patel]
-        # initial_state_dict = {
-        #     "project_json": project_skeleton,
-        #     "description": "The pseudo code for the script",
-        #     "project_id": project_id,
-        #     "project_image": img_b64,
-        #     "action_plan": {},
-        #     "pseudo_code": {},
-        #     "temporary_node": {},
-        # }
+        initial_state_dict = {
+            "project_json": project_skeleton,
+            "description": "The pseudo code for the script",
+            "project_id": project_id,
+            # "project_image": img_b64,
+            "project_image": images,
+            "action_plan": {},
+            "pseudo_code": {},
+            "temporary_node": {},
+        }
         
-        # final_state_dict = app_graph.invoke(initial_state_dict) # Pass dictionary
+        final_state_dict = app_graph.invoke(initial_state_dict) # Pass dictionary
 
-        # final_project_json = final_state_dict['project_json'] # Access as dict
+        final_project_json = final_state_dict['project_json'] # Access as dict
         # final_project_json = project_skeleton
         
         # Save the *final* filled project JSON, overwriting the skeleton
-        # with open(project_output, "w") as f:
-        #     json.dump(final_project_json, f, indent=2)
-        # logger.info(f"Final project JSON saved to {project_output}")
+        with open(project_output, "w") as f:
+            json.dump(final_project_json, f, indent=2)
+        logger.info(f"Final project JSON saved to {project_output}")
 
         # --- Call the new function to create the .sb3 file ---
-        # sb3_file_path = create_sb3_archive(project_folder, project_id)
-        sb3_file_path = BACKDROP_DIR #create_sb3_archive(project_folder, project_id)
+        sb3_file_path = create_sb3_archive(project_folder, project_id)
         
         if sb3_file_path:
             logger.info(f"Successfully created SB3 file: {sb3_file_path}")
@@ -2435,8 +2693,7 @@ def process_pdf():
                 "output_json": "output_path",
                 "sprites": "result",
                 "project_output_json": "project_output",
-                # "test_url": download_url
-                "test_url":r"https://prthm11-scratch-vision-game.hf.space/download_sb3/Event_test"
+                "test_url": download_url
             })
         else:
             return jsonify(error="Failed to create SB3 archive"), 500