Update app.py

app.py

@@ -141,27 +141,16 @@ for d in (
     # JSON_DIR,
 ):
     d.mkdir(parents=True, exist_ok=True)
-# def classify_image_type(description_or_name: str) -> str:
-#     desc = description_or_name.lower()
-
-#     sprite_keywords = ["sprite", "character", "animal", "person", "creature", "robot", "figure"]
-#     backdrop_keywords = ["background", "scene", "forest", "city", "room", "sky", "mountain", "village"]
-#     code_block_keywords = [
-#         "move", "turn", "wait", "repeat", "if", "else", "broadcast",
-#         "glide", "change", "forever", "when", "switch", "costume",
-#         "say", "think", "stop", "clone", "touching", "sensing",
-#         "scratch", "block", "code", "set", "variable"
-#     ]
-
-#     if any(kw in desc for kw in code_block_keywords):
-#         return "code-block"
-#     elif any(kw in desc for kw in sprite_keywords):
-#         return "sprite"
-#     elif any(kw in desc for kw in backdrop_keywords):
-#         return "backdrop"
-#     else:
-#         return "unknown"
       
+# class GameState(TypedDict):
+#     project_json: dict
+#     description: str
+#     project_id: str
+#     project_image: str
+#     pseudo_code: dict
+#     action_plan: Optional[Dict]
+#     temporary_node: Optional[Dict]
+
 class GameState(TypedDict):
     project_json: dict
     description: str
@@ -170,10 +159,9 @@ class GameState(TypedDict):
     pseudo_code: dict
     action_plan: Optional[Dict]
     temporary_node: Optional[Dict]
-    
-# class GameState(TypedDict):
-#     image: str
-#     pseudo_node: Optional[Dict]
+    page_count: int
+    processing: bool
+    temp_pseudo_code: list
     
 # Refined SYSTEM_PROMPT with more explicit Scratch JSON rules, especially for variables
 SYSTEM_PROMPT = """
@@ -278,25 +266,6 @@ agent_json_resolver = create_react_agent(
     prompt=SYSTEM_PROMPT_JSON_CORRECTOR 
 )
 
-# # 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:
-#         with open(file_path, 'r') as f:
-#             catalog = json.load(f)
-#         logger.info(f"Successfully loaded block catalog from {file_path}")
-#         return catalog
-#     except FileNotFoundError:
-#         logger.error(f"Error: Block catalog file not found at {file_path}")
-#         # Return an empty dict or raise an error, depending on desired behavior
-#         return {}
-#     except json.JSONDecodeError as e:
-#         logger.error(f"Error decoding JSON from {file_path}: {e}")
-#         return {}
-#     except Exception as e:
-#         logger.error(f"An unexpected error occurred while loading {file_path}: {e}")
-#         return {}
-
 # Helper function to load the block catalog from a JSON file
 def _load_block_catalog(block_type: str) -> Dict:
     """
@@ -654,48 +623,124 @@ 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.
+# 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}"
 
-    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
+def reduce_image_size_to_limit(clean_b64_str, max_kb=4000):
     """
+    Reduce an image's size to be as close as possible to max_kb without exceeding it.
+    Returns the final base64 string and its size in KB.
+    """
+    import re, base64
+    from io import BytesIO
+    from PIL import Image
+
+    # Remove the data URI prefix
+    base64_data = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", clean_b64_str)
+    image_data = base64.b64decode(base64_data)
+
+    # Load into PIL
+    img = Image.open(BytesIO(image_data))
+
+    low, high = 20, 95  # reasonable JPEG quality range
+    best_b64 = None
+    best_size_kb = 0
+
+    while low <= high:
+        mid = (low + high) // 2
+        buffer = BytesIO()
+        img.save(buffer, format="JPEG", quality=mid)
+        size_kb = len(buffer.getvalue()) / 1024
+
+        if size_kb <= max_kb:
+            # This quality is valid, try higher
+            best_b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+            best_size_kb = size_kb
+            low = mid + 1
+        else:
+            # Too big, try lower
+            high = mid - 1
+
+    return f"data:image/jpeg;base64,{best_b64}"
+
+#clean the base64 model here
+def clean_base64_for_model(raw_b64):
+    import io, base64, re
+    from PIL import Image
+
     if not raw_b64:
-        return ""
+        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 ""
+            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
+    # Remove data URI prefix if present
     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}"
-
+    # Log original size
+    original_size = len(clean_b64.encode("utf-8"))
+    print(f"Original Base64 size (bytes): {original_size}")
+    if original_size > 4000000:
+        # Reduce size to under 4 MB
+        reduced_b64 = reduce_image_size_to_limit(clean_b64, max_kb=4000)
+        clean_b64_2 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", reduced_b64)
+        clean_b64_2 = clean_b64_2.replace("\n", "").replace("\r", "").strip()
+        reduced_size = len(clean_b64_2.encode("utf-8"))
+        print(f"Reduced Base64 size (bytes): {reduced_size}")
+        # Return both prefixed and clean reduced versions
+        return f"data:image/jpeg;base64,{reduced_b64}"
+    return f"data:image/jpeg;base64,{clean_b64}"
+    
 def format_scratch_pseudo_code(code_string):
     """
     Parses and formats Scratch pseudo-code with correct indentation,
@@ -746,13 +791,13 @@ def format_scratch_pseudo_code(code_string):
 
     return '\n'.join(formatted_lines)
 
-
 # Node 1: Logic updating if any issue here
 def pseudo_generator_node(state: GameState):
     logger.info("--- Running plan_logic_aligner_node ---")
     image = state.get("project_image", "")  
     project_json = state["project_json"]
-    
+    cnt =state["page_count"]
+    print(f"The page number recived at the pseudo_generator node:-----> {cnt}")
     # MODIFICATION 1: Include 'Stage' in the list of names to plan for.
     # It's crucial to ensure 'Stage' is always present for its global role.
     target_names = [t["name"] for t in project_json["targets"]]
@@ -897,7 +942,7 @@ If you find any "Code-Blocks" then,
         "type": "image_url",
         "image_url": {
             # "url": f"data:image/png;base64,{image}"
-            "url": clean_base64_for_model(image)
+            "url": clean_base64_for_model(image[cnt])
         }
     }
 
@@ -1852,6 +1897,7 @@ def overall_block_builder_node_2(state: GameState):
 
 # Node 6: variable adder node
 def variable_adder_node(state: GameState):
+    logger.info("--- Running Variable Adder Node ---")
     project_json = state["project_json"]
     try:
         updated_project_json = variable_adder_main(project_json)
@@ -1861,239 +1907,23 @@ def variable_adder_node(state: GameState):
         else:
             print("Variable adder unable to add any variable inside the project!")
             state["project_json"]=project_json
+        state["page_count"] +=1
         return state
     except Exception as e:
         logger.error(f"Error in variable adder node while updating project_json': {e}")
         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"
-#                 ]
-
-# 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):
+# Node 7: variable adder node
+def processed_page_node(state: GameState):
+    logger.info("--- Processing the Pages Node ---")
+    image = state.get("project_image", "")  
+    cnt =state["page_count"]
+    print(f"The page processed for page:--------------> {cnt}")
+    if cnt<len(image):
+        state["processing"]= True
+    else:
+        state["processing"]= False
+    return state
 
 # Prepare manipulated sprite JSON structure
 manipulated_json = {}
@@ -2471,145 +2301,6 @@ def similarity_matching(sprites_data: str, project_folder: str) -> str:
         json.dump(final_project, f, indent=2)
 
     return project_json_path
-    # for sprite_idx, matched_idx in enumerate(most_similar_indices):
-    #     matched_image_path = folder_image_paths[matched_idx]
-    #     matched_image_path = os.path.normpath(matched_image_path)
-    #     print(" --------------------------------------1- matched_image_path ---------------------------------------",matched_image_path)
-    #     matched_folder = os.path.dirname(matched_image_path)
-    #     #folder_name = os.path.basename(matched_folder)
-    #     print(" --------------------------------------1- matched_folder ---------------------------------------",matched_folder)
-    #     if matched_folder in copied_folders:
-    #         continue
-    #     copied_folders.add(matched_folder)
-    #     logger.info(f"Matched image path: {matched_image_path}")
-
-    #     sprite_json_path = os.path.join(matched_folder, 'sprite.json')
-    #     print(" --------------------------------------- sprite_json_path ---------------------------------------",sprite_json_path)
-    #     if not os.path.exists(sprite_json_path):
-    #         logger.warning(f"sprite.json not found in: {matched_folder}")
-    #         continue
-
-    #     with open(sprite_json_path, 'r') as f:
-    #         sprite_data = json.load(f)
-    #         # print(f"SPRITE DATA: \n{sprite_data}")
-    #     # # Copy only non-matched files
-    #     # for fname in os.listdir(matched_folder):
-    #     #     fpath = os.path.join(matched_folder, fname)
-    #     #     if os.path.isfile(fpath) and fname not in {os.path.basename(matched_image_path), 'sprite.json'}:
-    #     #         shutil.copy2(fpath, os.path.join(project_folder, fname))
-    #     #         # logger.info(f"Copied Sprite asset: {fname}")
-    #     project_data.append(sprite_data)
-    #     print(" --------------------------------------1- project_data ---------------------------------------",project_data)
-    #     for fname in os.listdir(matched_folder):
-    #         fpath = os.path.join(matched_folder, fname)
-    #         dest_path = os.path.join(project_folder, fname)
-    #         if os.path.isfile(fpath) and fname not in {os.path.basename(matched_image_path), 'sprite.json'}:
-    #             shutil.copy2(fpath, dest_path)
-    #             logger.info(f"🟢 Copied Sprite Asset: {fpath} → {dest_path}")
-        
-    # # ================================================================== #
-    # #   Loop through most similar images from Backdrops folder           #
-    # #   → Copy Backdrop assets (excluding matched image + project.json)  #
-    # #   → Load project.json and append its data to project_data          #
-    # # ================================================================== #
-    # backdrop_data = []  # for backdrop-related entries
-
-    # for backdrop_idx, matched_idx in enumerate(most_similar_indices):
-    #     matched_image_path = os.path.normpath(folder_image_paths[matched_idx])
-    #     print(" --------------------------------------2- matched_image_path ---------------------------------------",matched_image_path)
-    #     # Check if the match is from the Backdrops folder
-    #     if matched_image_path.startswith(os.path.normpath(backdrop_images_path)):
-    #         matched_folder = os.path.dirname(matched_image_path)
-    #         print(" --------------------------------------2- matched_folder ---------------------------------------",matched_folder)
-    #         folder_name = os.path.basename(matched_folder)
-
-    #         logger.info(f"Backdrop matched image: {matched_image_path}")
-
-    #         # Copy only non-matched files
-    #         # for fname in os.listdir(matched_folder):
-    #         #     fpath = os.path.join(matched_folder, fname)
-    #         #     if os.path.isfile(fpath) and fname not in {os.path.basename(matched_image_path), 'project.json'}:
-    #         #         shutil.copy2(fpath, os.path.join(project_folder, fname))
-    #         #         # logger.info(f"Copied Backdrop asset: {fname}")
-    #         for fname in os.listdir(matched_folder):
-    #             fpath = os.path.join(matched_folder, fname)
-    #             dest_path = os.path.join(project_folder, fname)
-    #             if os.path.isfile(fpath) and fname not in {os.path.basename(matched_image_path), 'project.json'}:
-    #                 shutil.copy2(fpath, dest_path)
-    #                 logger.info(f"🟡 Copied Backdrop Asset: {fpath} → {dest_path}")
-
-
-    #         # Append backdrop's project.json
-    #         backdrop_json_path = os.path.join(matched_folder, 'project.json')
-    #         print(" --------------------------------------2- backdrop_json_path ---------------------------------------",backdrop_json_path)
-    #         if os.path.exists(backdrop_json_path):
-    #             with open(backdrop_json_path, 'r') as f:
-    #                 backdrop_json_data = json.load(f)
-    #                 # print(f"SPRITE DATA: \n{backdrop_json_data}")
-    #             if "targets" in backdrop_json_data:
-    #                 for target in backdrop_json_data["targets"]:
-    #                     if target.get("isStage") == True:
-    #                         backdrop_data.append(target)
-    #         else:
-    #             logger.warning(f"project.json not found in: {matched_folder}")
-
-    # # Merge JSON structure
-    # final_project = {
-    #     "targets": [],
-    #     "monitors": [],
-    #     "extensions": [],
-    #     "meta": {
-    #         "semver": "3.0.0",
-    #         "vm": "11.3.0",
-    #         "agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
-    #     }
-    # }
-
-    # for sprite in project_data:
-    #     if not sprite.get("isStage", False):
-    #         final_project["targets"].append(sprite)
-
-    # if backdrop_data:
-    #     all_costumes, sounds = [], []
-    #     for idx, bd in enumerate(backdrop_data):
-    #         all_costumes.extend(bd.get("costumes", []))
-    #         if idx == 0 and "sounds" in bd:
-    #             sounds = bd["sounds"]
-    #     final_project["targets"].append({
-    #         "isStage": True,
-    #         "name": "Stage",
-    #         "variables": {},
-    #         "lists": {},
-    #         "broadcasts": {},
-    #         "blocks": {},
-    #         "comments": {},
-    #         "currentCostume": 1 if len(all_costumes) > 1 else 0,
-    #         "costumes": all_costumes,
-    #         "sounds": sounds,
-    #         "volume": 100,
-    #         "layerOrder": 0,
-    #         "tempo": 60,
-    #         "videoTransparency": 50,
-    #         "videoState": "on",
-    #         "textToSpeechLanguage": None
-    #     })
-
-    # with open(project_json_path, 'w') as f:
-    #     json.dump(final_project, f, indent=2)
-
-    # # 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
@@ -2625,7 +2316,7 @@ def convert_pdf_stream_to_images(pdf_stream: io.BytesIO, dpi=300):
 
 def delay_for_tpm_node(state: GameState):
     logger.info("--- Running DelayForTPMNode ---")
-    time.sleep(1)  # Adjust the delay as needed
+    time.sleep(10)  # Adjust the delay as needed
     logger.info("Delay completed.")
     return state
 
@@ -2645,18 +2336,37 @@ workflow.add_node("refined_planner", refined_planner_node) # Refines the action
 workflow.add_node("opcode_counter", plan_opcode_counter_node)
 workflow.add_node("block_builder", overall_block_builder_node_2)
 workflow.add_node("variable_initializer", variable_adder_node)
+workflow.add_node("page_processed", processed_page_node)
+
+workflow.set_entry_point("page_processed")
+# Conditional branching from the start
+def decide_next_step(state: GameState):
+    if state.get("processing", False):
+        return "pseudo_generator"
+    else:
+        return END
+
+workflow.add_conditional_edges(
+    "page_processed",
+    decide_next_step,
+    {
+        "pseudo_generator": "pseudo_generator",
+        "END": END
+    }
+)
+# Main chain
+workflow.add_edge("pseudo_generator", "time_delay_1")
+workflow.add_edge("time_delay_1", "plan_generator")
+workflow.add_edge("plan_generator", "time_delay_2")
+workflow.add_edge("time_delay_2", "refined_planner")
+workflow.add_edge("refined_planner", "time_delay_3")
+workflow.add_edge("time_delay_3", "opcode_counter")
+workflow.add_edge("opcode_counter", "block_builder")
+workflow.add_edge("block_builder", "variable_initializer")
+
+# After last node, check again
+workflow.add_edge("variable_initializer", "page_processed")
 
-workflow.set_entry_point("pseudo_generator")
-workflow.add_edge("pseudo_generator","time_delay_1")
-workflow.add_edge("time_delay_1","plan_generator")
-workflow.add_edge("plan_generator","time_delay_2")
-# workflow.add_edge("time_delay_2",END)
-workflow.add_edge("time_delay_2","refined_planner")
-workflow.add_edge("refined_planner","time_delay_3")
-workflow.add_edge("time_delay_3","opcode_counter")
-workflow.add_edge("opcode_counter","block_builder")
-workflow.add_edge("block_builder","variable_initializer")
-workflow.add_edge("variable_initializer", END)
 app_graph = workflow.compile()
 
 # ============== Helper function to Upscale an Image ============== #
@@ -2758,56 +2468,6 @@ def save_pdf_to_generated_dir(pdf_stream: io.BytesIO, project_id: str) -> str:
         logger.error(f"Failed to save PDF to generated dir: {e}", exc_info=True)
         return None
 
-# def pdf_to_images_with_size_check(pdf_path, output_dir, size_limit_mb=4):
-#     os.makedirs(output_dir, exist_ok=True)
-
-#     # Convert PDF to images
-#     images = convert_from_path(pdf_path, dpi=300)  # 300 DPI keeps quality
-#     saved_files = []
-
-#     for i, img in enumerate(images, start=1):
-#         output_path = os.path.join(output_dir, f"page_{i}.jpg")
-
-#         # Save to memory first to check size
-#         img_bytes = io.BytesIO()
-#         img.save(img_bytes, format="JPEG", quality=95)  # near-lossless
-#         size_mb = len(img_bytes.getvalue()) / (1024 * 1024)
-
-#         if size_mb > size_limit_mb:
-#             print(f"Page {i}: {size_mb:.2f} MB → compressing...")
-#             # Compress until under size limit
-#             quality = 95
-#             while size_mb > size_limit_mb and quality > 70:  # don't go below 70
-#                 img_bytes = io.BytesIO()
-#                 img.save(img_bytes, format="JPEG", quality=quality)
-#                 size_mb = len(img_bytes.getvalue()) / (1024 * 1024)
-#                 quality -= 5
-#         else:
-#             print(f"Page {i}: {size_mb:.2f} MB → no compression needed.")
-
-#         # Write final image to disk
-#         with open(output_path, "wb") as f:
-#             f.write(img_bytes.getvalue())
-
-#         saved_files.append(output_path)
-
-#     return saved_files
-def compress_image_if_needed(image, max_size_mb=4, quality=85):
-    """
-    Compress the given PIL Image if its size is greater than max_size_mb.
-    Returns the (possibly compressed) image object.
-    """
-    temp_path = "/tmp/temp_compression_check.jpg"
-    image.save(temp_path, format="JPEG", quality=95)  # save original temporarily
-    size_mb = os.path.getsize(temp_path) / (1024 * 1024)
-
-    if size_mb > max_size_mb:
-        # Compress by reducing quality
-        image.save(temp_path, format="JPEG", quality=quality, optimize=True)
-        print(f"Image compressed from {size_mb:.2f} MB to {os.path.getsize(temp_path)/(1024*1024):.2f} MB")
-        return Image.open(temp_path)
-    return image
-
 @app.route('/')
 def index():
     return render_template('app_index.html')
@@ -2934,12 +2594,6 @@ def process_pdf():
             images = convert_pdf_stream_to_images(pdf_stream, dpi=300)
         else:
             images = convert_from_path(pdf_stream, dpi=300)
-
-        # Compress images if needed
-        compressed_images = []
-        for img in images:
-            compressed_images.append(compress_image_if_needed(img, max_size_mb=4, quality=85))
-        images = compressed_images
         
         #updating logic here [Dev Patel]
         initial_state_dict = {
@@ -2951,6 +2605,10 @@ def process_pdf():
             "action_plan": {},
             "pseudo_code": {},
             "temporary_node": {},
+            "temporary_node": {},
+            "processing":True,
+            "page_count": 0,
+            "temp_pseudo_code":{},
         }
         
         final_state_dict = app_graph.invoke(initial_state_dict) # Pass dictionary