Update app.py

app.py

@@ -8,25 +8,27 @@ from werkzeug.utils import secure_filename
 from langchain_groq import ChatGroq
 from langgraph.prebuilt import create_react_agent
 from pdf2image import convert_from_path, convert_from_bytes
-from typing import Dict, TypedDict, Optional, Any
+from typing import Dict, TypedDict, Optional, Any, List, Tuple
+from collections import defaultdict
 from langgraph.graph import StateGraph, END
 import uuid
 import shutil, time, functools
 from io import BytesIO
 from pathlib import Path
-import os
 from utils.block_relation_builder import block_builder, separate_scripts, transform_logic_to_action_flow, analyze_opcode_counts
 from difflib import get_close_matches
 import torch
 from transformers import AutoImageProcessor, AutoModel
-from pathlib import Path
-from io import BytesIO
 import torch
 import json
 import cv2
-# hashing & image-match
 from imagededup.methods import PHash
 from image_match.goldberg import ImageSignature
+import sys
+import math
+import hashlib
+
+
 # DINOv2 model id
 DINOV2_MODEL = "facebook/dinov2-small"
 
@@ -346,13 +348,225 @@ def cosine_similarity(a, b):
     return float(np.dot(a, b))
 
 
+# --------------------------
+# Hybrid Selection of Best Match
+# --------------------------
+
+def run_query_search_flow(
+    query_path: Optional[str] = None,
+    query_b64: Optional[str] = None,
+    processed_dir: str = "./processed",
+    embeddings_dict: Dict[str, np.ndarray] = None,
+    hash_dict: Dict[str, Any] = None,
+    signature_obj_map: Dict[str, Any] = None,
+    gis: Any = None,
+    phash: Any = None,
+    MAX_PHASH_BITS: int = 64,
+    k: int = 10,
+) -> Tuple[
+    List[Tuple[str, float]],
+    List[Tuple[str, Any, float]],
+    List[Tuple[str, Any, float]],
+    List[Tuple[str, float, float, float, float]],
+]:
+    """
+    Run the full query/search flow (base64 -> preprocess -> embed -> scoring).
+    Accepts either query_path (file on disk) OR query_b64 (base64 string). If both are
+    provided, query_b64 takes precedence.
+
+    Returns:
+        embedding_results_sorted,
+        phash_results_sorted,
+        imgmatch_results_sorted,
+        combined_results_sorted
+    """
+
+    # Validate inputs
+    if (query_path is None or query_path == "") and (query_b64 is None or query_b64 == ""):
+        raise ValueError("Either query_path or query_b64 must be provided.")
+
+    # Ensure processed_dir exists
+    os.makedirs(processed_dir, exist_ok=True)
+
+    print("\n--- Query/Search Phase ---")
+
+    # 1) Load query image (prefer base64 if provided)
+    if query_b64:
+        # base64 provided directly -> decode to PIL
+        query_from_b64 = base64_to_pil(query_b64)
+        if query_from_b64 is None:
+            raise RuntimeError("Could not decode provided base64 query. Exiting.")
+        query_pil_orig = query_from_b64
+    else:
+        # load from disk
+        if not os.path.exists(query_path):
+            raise FileNotFoundError(f"Query image not found: {query_path}")
+        query_pil_orig = load_image_pil(query_path)
+        if query_pil_orig is None:
+            raise RuntimeError("Could not load query image from path. Exiting.")
+
+        # also create a base64 roundtrip for robustness (keep original behaviour)
+        try:
+            query_b64 = pil_to_base64(query_pil_orig, fmt="PNG")
+        except Exception as e:
+            raise RuntimeError(f"Could not base64 query from disk image: {e}")
+        # keep decoded copy for consistency
+        query_from_b64 = base64_to_pil(query_b64)
+        if query_from_b64 is None:
+            raise RuntimeError("Could not decode query base64 after roundtrip. Exiting.")
+
+    # At this point, query_from_b64 is a PIL.Image we can continue with
+    # 2) Preprocess with OpenCV enhancement (best-effort; fallback to base64-decoded image)
+    enhanced_query_pil = process_image_cv2_from_pil(query_from_b64, scale=2)
+    if enhanced_query_pil is None:
+        print("[Query] OpenCV enhancement failed; falling back to base64-decoded image.")
+        enhanced_query_pil = query_from_b64
+
+    # Save the enhanced query (best-effort)
+    query_enhanced_path = os.path.join(processed_dir, "query_enhanced.png")
+    try:
+        enhanced_query_pil.save(query_enhanced_path, format="PNG")
+    except Exception:
+        try:
+            enhanced_query_pil.convert("RGB").save(query_enhanced_path, format="PNG")
+        except Exception:
+            print("[Warning] Could not save enhanced query image for inspection.")
+
+    # 3) Query embedding (preprocess -> model)
+    prepped = preprocess_for_model(enhanced_query_pil)
+    query_emb = get_dinov2_embedding_from_pil(prepped)
+    if query_emb is None:
+        raise RuntimeError("Could not compute query embedding. Exiting.")
+
+    # 4) Query phash computation
+    query_hash_arr = preprocess_for_hash(enhanced_query_pil)
+    if query_hash_arr is None:
+        raise RuntimeError("Could not compute query phash array. Exiting.")
+    query_phash = phash.encode_image(image_array=query_hash_arr)
+
+    # 5) Query signature generation (best-effort)
+    query_sig = None
+    query_sig_path = os.path.join(processed_dir, "query_for_sig.png")
+    try:
+        enhanced_query_pil.save(query_sig_path, format="PNG")
+    except Exception:
+        try:
+            enhanced_query_pil.convert("RGB").save(query_sig_path, format="PNG")
+        except Exception:
+            query_sig_path = None
+
+    if query_sig_path:
+        try:
+            query_sig = gis.generate_signature(query_sig_path)
+        except Exception as e:
+            print(f"[ImageSignature] failed for query: {e}")
+            query_sig = None
+
+    # -----------------------
+    # Prepare stored data arrays
+    # -----------------------
+    embeddings_dict = embeddings_dict or {}
+    hash_dict = hash_dict or {}
+    signature_obj_map = signature_obj_map or {}
+
+    image_paths = list(embeddings_dict.keys())
+    image_embeddings = np.array(list(embeddings_dict.values()), dtype=float) if embeddings_dict else np.array([])
+
+    def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+        try:
+            return float(np.dot(a, b))
+        except Exception:
+            return -1.0
+
+    # Collections
+    embedding_results: List[Tuple[str, float]] = []
+    phash_results: List[Tuple[str, Any, float]] = []
+    imgmatch_results: List[Tuple[str, Any, float]] = []
+    combined_results: List[Tuple[str, float, float, float, float]] = []
+
+    # Iterate stored images and compute similarities
+    for idx, path in enumerate(image_paths):
+        # Embedding similarity
+        try:
+            stored_emb = image_embeddings[idx]
+            emb_sim = cosine_similarity(query_emb, stored_emb)
+        except Exception:
+            emb_sim = -1.0
+        embedding_results.append((path, emb_sim))
+
+        # PHash similarity (Hamming -> normalized sim)
+        try:
+            stored_ph = hash_dict.get(path)
+            if stored_ph is not None:
+                hd = phash.hamming_distance(query_phash, stored_ph)
+                ph_sim = max(0.0, 1.0 - (hd / float(MAX_PHASH_BITS)))
+            else:
+                hd = None
+                ph_sim = 0.0
+        except Exception:
+            hd = None
+            ph_sim = 0.0
+        phash_results.append((path, hd, ph_sim))
+
+        # Image signature similarity (normalized distance -> similarity)
+        try:
+            stored_sig = signature_obj_map.get(path)
+            if stored_sig is not None and query_sig is not None:
+                dist = gis.normalized_distance(stored_sig, query_sig)
+                im_sim = max(0.0, 1.0 - dist)
+            else:
+                dist = None
+                im_sim = 0.0
+        except Exception:
+            dist = None
+            im_sim = 0.0
+        imgmatch_results.append((path, dist, im_sim))
+
+        # Combined score: average of the three (embedding is clamped into [0,1])
+        emb_clamped = max(0.0, min(1.0, emb_sim))
+        combined = (emb_clamped + ph_sim + im_sim) / 3.0
+        combined_results.append((path, combined, emb_clamped, ph_sim, im_sim))
+
+    # -----------------------
+    # Sort results
+    # -----------------------
+    embedding_results.sort(key=lambda x: x[1], reverse=True)
+    phash_results_sorted = sorted(phash_results, key=lambda x: (x[2] is not None, x[2]), reverse=True)
+    imgmatch_results_sorted = sorted(imgmatch_results, key=lambda x: (x[2] is not None, x[2]), reverse=True)
+    combined_results.sort(key=lambda x: x[1], reverse=True)
+
+    # -----------------------
+    # Print Top-K results
+    # -----------------------
+    print("\nTop results by DINOv2 Embeddings:")
+    for i, (path, score) in enumerate(embedding_results[:k], start=1):
+        print(f"Rank {i}: {path} | Cosine: {score:.4f}")
+
+    print("\nTop results by PHash (Hamming distance & normalized sim):")
+    for i, (path, hd, sim) in enumerate(phash_results_sorted[:k], start=1):
+        print(f"Rank {i}: {path} | Hamming: {hd} | NormSim: {sim:.4f}")
+
+    print("\nTop results by ImageSignature (normalized similarity = 1 - distance):")
+    for i, (path, dist, sim) in enumerate(imgmatch_results_sorted[:k], start=1):
+        print(f"Rank {i}: {path} | NormDist: {dist} | NormSim: {sim:.4f}")
+
+    print("\nTop results by Combined Score (avg of embedding|phash|image-match):")
+    for i, (path, combined, emb_clamped, ph_sim, im_sim) in enumerate(combined_results[:k], start=1):
+        print(f"Rank {i}: {path} | Combined: {combined:.4f} | emb: {emb_clamped:.4f} | phash_sim: {ph_sim:.4f} | imgmatch_sim: {im_sim:.4f}")
+
+    print("\nSearch complete.")
+
+    # Return sorted lists for programmatic consumption
+    return embedding_results, phash_results_sorted, imgmatch_results_sorted, combined_results
+
 # --------------------------
 # Choose best candidate helper
 # --------------------------
 from collections import defaultdict
 import math
 
-def choose_top_candidates(embedding_results, phash_results, imgmatch_results, top_k=10, method_weights=(0.5, 0.3, 0.2), verbose=True):
+def choose_top_candidates(embedding_results, phash_results, imgmatch_results, top_k=10,
+                          method_weights=(0.5, 0.3, 0.2), verbose=True):
     """
     embedding_results: list of (path, emb_sim) where emb_sim roughly in [-1,1] (we'll clamp to 0..1)
     phash_results: list of (path, hamming, ph_sim) where ph_sim in [0,1]
@@ -1383,60 +1597,99 @@ def processed_page_node(state: GameState):
         state["processing"]= False
     return state
 
-def extract_images_from_pdf(pdf_stream: io.BytesIO):
-    ''' Extract images from PDF and generate structured sprite JSON '''
+# def extract_images_from_pdf(pdf_stream: io.BytesIO):
+#     ''' Extract images from PDF and generate structured sprite JSON '''
+#     manipulated_json = {}
+#     img_elements = []
+#     try:
+
+#         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]
+
+#         try:
+#             elements = partition_pdf(
+#                 file=pdf_stream,
+#                 strategy="hi_res",
+#                 # strategy="fast",
+#                 extract_image_block_types=["Image"],
+#                 hi_res_model_name="yolox",
+#                 extract_image_block_to_payload=True,
+#             )
+#             print(f"ELEMENTS")
+#         except Exception as e:
+#             raise RuntimeError(
+#                 f"❌ Failed to extract images from PDF: {str(e)}")
+ 
+#         file_elements = [element.to_dict() for element in elements]
+#         print(f"========== file elements: \n{file_elements}")
+        
+#         sprite_count = 1
+#         for el in file_elements:
+#             img_b64 = el["metadata"].get("image_base64")
+#             if not img_b64:
+#                 continue
+           
+#             manipulated_json[f"Sprite {sprite_count}"] = {
+#                 "base64": el["metadata"]["image_base64"],
+#                 "file-path": pdf_id,
+#             }
+#             sprite_count += 1
+#         return manipulated_json
+#     except Exception as e:
+#         raise RuntimeError(f"❌ Error in extract_images_from_pdf: {str(e)}")
+
+def extract_images_from_pdf(pdf_stream, output_dir):
     manipulated_json = {}
-    img_elements = []
     try:
-
-        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]
-
-        try:
-            elements = partition_pdf(
-                file=pdf_stream,
-                strategy="hi_res",
-                # strategy="fast",
-                extract_image_block_types=["Image"],
-                hi_res_model_name="yolox",
-                extract_image_block_to_payload=True,
-            )
-            print(f"ELEMENTS")
-        except Exception as e:
-            raise RuntimeError(
-                f"❌ Failed to extract images from PDF: {str(e)}")
- 
+        pdf_id = uuid.uuid4().hex
+        elements = partition_pdf(
+            file=pdf_stream,
+            strategy="hi_res",
+            extract_image_block_types=["Image"],
+            hi_res_model_name="yolox",
+            extract_image_block_to_payload=False,
+            extract_image_block_output_dir=BLOCKS_DIR,
+        )
         file_elements = [element.to_dict() for element in elements]
-        print(f"========== file elements: \n{file_elements}")
-        
         sprite_count = 1
         for el in file_elements:
-            img_b64 = el["metadata"].get("image_base64")
-            if not img_b64:
+            img_path = el["metadata"].get("image_path")
+
+            # ✅ skip if no image_path was returned
+            if not img_path:
                 continue
-           
+
+            with open(img_path, "rb") as f:
+                base_file = base64.b64encode(f.read()).decode("utf-8")
+
+            image_uuid = str(uuid.uuid4())
             manipulated_json[f"Sprite {sprite_count}"] = {
-                "base64": el["metadata"]["image_base64"],
-                "file-path": pdf_id,
+                "base64": base_file,
+                "file-path": img_path,
+                "pdf-id": pdf_id,
+                "image-uuid": image_uuid,
             }
+
             sprite_count += 1
+
         return manipulated_json
     except Exception as e:
         raise RuntimeError(f"❌ Error in extract_images_from_pdf: {str(e)}")
-        
-''' It appends all the list and paths from json files and pick the best match's path'''
+
+
+
 def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1, min_similarity: float = None) -> str:
     print("🔍 Running similarity matching…")
-    import os
-    import json
     os.makedirs(project_folder, exist_ok=True)
 
-    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))
+    backdrop_base_path = r"D:\DEV PATEL\2025\scratch_VLM\scratch_agent\blocks\Backdrops"
+    sprite_base_path   = r"D:\DEV PATEL\2025\scratch_VLM\scratch_agent\blocks\sprites"
+    code_blocks_path = r"D:\DEV PATEL\2025\scratch_VLM\scratch_agent\blocks\code_blocks"
+    # out_path = r"D:\DEV PATEL\2025\scratch_VLM\scratch_agent\blocks\out_json"
+    
 
     project_json_path = os.path.join(project_folder, "project.json")
 
@@ -1449,73 +1702,64 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
         sprite_base64.append(sprite["base64"])
 
     sprite_images_bytes = []
+    sprite_b64_clean = []         # <<< new: store cleaned base64 strings
     for b64 in sprite_base64:
-        img = Image.open(BytesIO(base64.b64decode(b64.split(",")[-1]))).convert("RGB")
+        # remove possible "data:image/..;base64," prefix
+        raw_b64 = b64.split(",")[-1]
+        sprite_b64_clean.append(raw_b64)
+
+        # decode into BytesIO for local processing
+        img = Image.open(BytesIO(base64.b64decode(raw_b64))).convert("RGB")
         buffer = BytesIO()
         img.save(buffer, format="PNG")
         buffer.seek(0)
         sprite_images_bytes.append(buffer)
-
-    # -----------------------------------------
-    #  Hybrid Similarity Matching System
-    # -----------------------------------------
-    def hybrid_similarity_matching(sprite_images_bytes, sprite_ids, 
-                                 min_similarity=None, top_k=5, method_weights=(0.5, 0.3, 0.2)):
-        """
-        Hybrid similarity matching using DINOv2 embeddings, perceptual hashing, and image signatures
-        
-        Args:
-            sprite_images_bytes: List of image bytes
-            sprite_ids: List of sprite identifiers
-            blocks_dir: Directory containing reference blocks
-            min_similarity: Minimum similarity threshold
-            top_k: Number of top matches to return
-            method_weights: Weights for (embedding, phash, image_signature) methods
-            
-        Returns:
-            per_sprite_matched_indices, per_sprite_scores, paths_list
-        """
-        import imagehash as phash
-        from image_match.goldberg import ImageSignature
-        import math
-        from collections import defaultdict
-        
-        # Load reference data
+    
+    def hybrid_similarity_matching(sprite_images_bytes, sprite_ids, min_similarity=None, top_k=5, method_weights=(0.5,0.3,0.2)):
+        from PIL import Image
+        # Local safe defaults
         embeddings_path = os.path.join(BLOCKS_DIR, "hybrid_embeddings.json")
-        hash_path = os.path.join(BLOCKS_DIR, "phash_data.json") 
+        hash_path = os.path.join(BLOCKS_DIR, "phash_data.json")
         signature_path = os.path.join(BLOCKS_DIR, "signature_data.json")
-        
+
         # Load embeddings
-        with open(embeddings_path, "r", encoding="utf-8") as f:
-            embedding_json = json.load(f)
-            
-        # Load phash data (if exists)
+        embedding_json = {}
+        if os.path.exists(embeddings_path):
+            with open(embeddings_path, "r", encoding="utf-8") as f:
+                embedding_json = json.load(f)
+
+        # Load phash data (if exists) -> ensure hash_dict variable exists
         hash_dict = {}
         if os.path.exists(hash_path):
-            with open(hash_path, "r", encoding="utf-8") as f:
-                hash_data = json.load(f)
-                for path, hash_str in hash_data.items():
-                    try:
-                        hash_dict[path] = phash.hex_to_hash(hash_str)
-                    except:
-                        pass
-        
-        # Load signature data (if exists)
+            try:
+                with open(hash_path, "r", encoding="utf-8") as f:
+                    hash_data = json.load(f)
+                    for path, hash_str in hash_data.items():
+                        try:
+                            hash_dict[path] = hash_str
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # Load signature data (if exists) -> ensure signature_dict exists
         signature_dict = {}
-        gis = ImageSignature()
+        sig_data = {}
         if os.path.exists(signature_path):
-            with open(signature_path, "r", encoding="utf-8") as f:
-                sig_data = json.load(f)
-                for path, sig_list in sig_data.items():
-                    try:
-                        signature_dict[path] = np.array(sig_list)
-                    except:
-                        pass
-        
-        # Parse embeddings
+            try:
+                with open(signature_path, "r", encoding="utf-8") as f:
+                    sig_data = json.load(f)
+                    for path, sig_list in sig_data.items():
+                        try:
+                            signature_dict[path] = np.array(sig_list)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # Parse embeddings into lists
         paths_list = []
         embeddings_list = []
-        
         if isinstance(embedding_json, dict):
             for p, emb in embedding_json.items():
                 if isinstance(emb, dict):
@@ -1539,294 +1783,77 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
                     continue
                 paths_list.append(os.path.normpath(str(p)))
                 embeddings_list.append(np.asarray(emb, dtype=np.float32))
-        
+
         if len(paths_list) == 0:
-            raise RuntimeError("No reference images/embeddings found")
-            
+            print("⚠ No reference images/embeddings found (this test harness may be running without data)")
+            # Return empty results gracefully
+            return [[] for _ in sprite_images_bytes], [[] for _ in sprite_images_bytes], []
+
         ref_matrix = np.vstack(embeddings_list).astype(np.float32)
         
-        # Process input sprites
-        # init_dinov2()
-        per_sprite_matched_indices = []
-        per_sprite_scores = []
-        
-        for i, (sprite_bytes, sprite_id) in enumerate(zip(sprite_images_bytes, sprite_ids)):
-            print(f"Processing sprite {i+1}/{len(sprite_ids)}: {sprite_id}")
-            
-            # Convert bytes to PIL for processing
+        # Batch: Get all sprite embeddings, phash, sigs first
+        sprite_emb_list = []
+        sprite_phash_list = []
+        sprite_sig_list = []
+        per_sprite_final_indices = []
+        per_sprite_final_scores = []
+        per_sprite_rerank_debug = []
+        for i, sprite_bytes in enumerate(sprite_images_bytes):
             sprite_pil = Image.open(sprite_bytes)
-            if sprite_pil is None:
-                per_sprite_matched_indices.append([])
-                per_sprite_scores.append([])
-                continue
-                
-            # Enhance image
-            enhanced_sprite = process_image_cv2_from_pil(sprite_pil, scale=2)
-            if enhanced_sprite is None:
-                enhanced_sprite = sprite_pil
-            
-            # 1. Compute DINOv2 embedding
+            enhanced_sprite = process_image_cv2_from_pil(sprite_pil, scale=2) or sprite_pil
+            # sprite_emb = get_dinov2_embedding_from_pil(preprocess_for_model(enhanced_sprite)) or np.zeros(ref_matrix.shape[1])
+            # sprite_emb_list.append(sprite_emb)
             sprite_emb = get_dinov2_embedding_from_pil(preprocess_for_model(enhanced_sprite))
-            if sprite_emb is None:
-                sprite_emb = np.zeros(ref_matrix.shape[1])
-            
-            # 2. Compute perceptual hash
+            sprite_emb = sprite_emb if sprite_emb is not None else np.zeros(ref_matrix.shape[1])
+            sprite_emb_list.append(sprite_emb)
+            # Perceptual hash
             sprite_hash_arr = preprocess_for_hash(enhanced_sprite)
             sprite_phash = None
             if sprite_hash_arr is not None:
-                try:
-                    sprite_phash = phash.encode_image(image_array=sprite_hash_arr)
-                except:
-                    pass
-            
-            # 3. Compute image signature
+                try: sprite_phash = phash.encode_image(image_array=sprite_hash_arr)
+                except: pass
+            sprite_phash_list.append(sprite_phash)
+            # Signature
             sprite_sig = None
-            try:
-                temp_path = f"temp_sprite_{i}.png"
-                enhanced_sprite.save(temp_path, format="PNG")
-                sprite_sig = gis.generate_signature(temp_path)
-                os.remove(temp_path)
-            except:
-                pass
-            
-            # Calculate similarities for all reference images
-            embedding_results = []
-            phash_results = []
-            signature_results = []
-            
-            for j, ref_path in enumerate(paths_list):
-                # Embedding similarity
-                try:
-                    ref_emb = ref_matrix[j]
-                    emb_sim = float(np.dot(sprite_emb, ref_emb))
-                    emb_sim = max(0.0, emb_sim)  # Clamp negative values
-                except:
-                    emb_sim = 0.0
-                embedding_results.append((ref_path, emb_sim))
-                
-                # Phash similarity
-                ph_sim = 0.0
-                if sprite_phash is not None and ref_path in hash_dict:
-                    try:
-                        ref_hash = hash_dict[ref_path]
-                        hd = phash.hamming_distance(sprite_phash, ref_hash)
-                        ph_sim = max(0.0, 1.0 - (hd / 64.0))  # Normalize to [0,1]
-                    except:
-                        pass
-                phash_results.append((ref_path, ph_sim))
-                
-                # Signature similarity
-                sig_sim = 0.0
-                if sprite_sig is not None and ref_path in signature_dict:
-                    try:
-                        ref_sig = signature_dict[ref_path]
-                        dist = gis.normalized_distance(ref_sig, sprite_sig)
-                        sig_sim = max(0.0, 1.0 - dist)
-                    except:
-                        pass
-                signature_results.append((ref_path, sig_sim))
-            
-            # Combine similarities using weighted approach
-            def normalize_scores(scores):
-                """Normalize scores to [0,1] range"""
-                if not scores:
-                    return {}
-                vals = [s for _, s in scores if not math.isnan(s)]
-                if not vals:
-                    return {p: 0.0 for p, _ in scores}
-                vmin, vmax = min(vals), max(vals)
-                if vmax == vmin:
-                    return {p: 1.0 if s == vmax else 0.0 for p, s in scores}
-                return {p: (s - vmin) / (vmax - vmin) for p, s in scores}
-            
-            # Normalize each method's scores
-            emb_norm = normalize_scores(embedding_results)
-            ph_norm = normalize_scores(phash_results)
-            sig_norm = normalize_scores(signature_results)
-            
-            # Calculate weighted combined scores
-            w_emb, w_ph, w_sig = method_weights
-            combined_scores = []
-            
-            for ref_path in paths_list:
-                combined_score = (w_emb * emb_norm.get(ref_path, 0.0) + 
-                                w_ph * ph_norm.get(ref_path, 0.0) + 
-                                w_sig * sig_norm.get(ref_path, 0.0))
-                combined_scores.append((ref_path, combined_score))
-            
-            # Sort by combined score and apply thresholds
-            combined_scores.sort(key=lambda x: x[1], reverse=True)
-            
-            # Filter by minimum similarity if specified
-            if min_similarity is not None:
-                combined_scores = [(p, s) for p, s in combined_scores if s >= float(min_similarity)]
-            
-            # Get top-k matches
-            top_matches = combined_scores[:int(top_k)]
-            
-            # Convert to indices and scores
-            matched_indices = []
-            matched_scores = []
-            
-            for ref_path, score in top_matches:
-                try:
-                    idx = paths_list.index(ref_path)
-                    matched_indices.append(idx)
-                    matched_scores.append(score)
-                except ValueError:
-                    continue
-            
-            per_sprite_matched_indices.append(matched_indices)
-            per_sprite_scores.append(matched_scores)
-            
-            print(f"Sprite '{sprite_id}' matched {len(matched_indices)} references with scores: {matched_scores}")
-        
-        return per_sprite_matched_indices, per_sprite_scores, paths_list
-    
-    def choose_top_candidates_advanced(embedding_results, phash_results, imgmatch_results, top_k=10,
-                              method_weights=(0.5, 0.3, 0.2), verbose=True):
-        """
-        Advanced candidate selection using multiple ranking methods
-        
-        Args:
-            embedding_results: list of (path, emb_sim)
-            phash_results: list of (path, hamming, ph_sim) 
-            imgmatch_results: list of (path, dist, im_sim)
-            top_k: number of top candidates to return
-            method_weights: weights for (emb, phash, imgmatch)
-            verbose: whether to print detailed results
-            
-        Returns:
-            dict with top candidates from different methods and final selection
-        """
-        import math
-        from collections import defaultdict
-        
-        # Build dicts for quick lookup
-        emb_map = {p: float(s) for p, s in embedding_results}
-        ph_map = {p: float(sim) for p, _, sim in phash_results}
-        im_map = {p: float(sim) for p, _, sim in imgmatch_results}
-
-        # Universe of candidates (union)
-        all_paths = sorted(set(list(emb_map.keys()) + list(ph_map.keys()) + list(im_map.keys())))
-
-        # Normalize each metric across candidates to [0,1]
-        def normalize_map(m):
-            vals = [m.get(p, None) for p in all_paths]
-            present = [v for v in vals if v is not None and not math.isnan(v)]
-            if not present:
-                return {p: 0.0 for p in all_paths}
-            vmin, vmax = min(present), max(present)
-            if vmax == vmin:
-                return {p: (1.0 if (m.get(p, None) is not None) else 0.0) for p in all_paths}
-            norm = {}
-            for p in all_paths:
-                v = m.get(p, None)
-                if v is None or math.isnan(v):
-                    norm[p] = 0.0
-                else:
-                    norm[p] = max(0.0, min(1.0, (v - vmin) / (vmax - vmin)))
-            return norm
-
-        # For embeddings, clamp negatives to 0 first
-        emb_map_clamped = {p: max(0.0, v) for p, v in emb_map.items()}
-
-        emb_norm = normalize_map(emb_map_clamped)
-        ph_norm  = normalize_map(ph_map)
-        im_norm  = normalize_map(im_map)
-
-        # Method A: Normalized weighted average
-        w_emb, w_ph, w_im = method_weights
-        weighted_scores = {}
-        for p in all_paths:
-            weighted_scores[p] = (w_emb * emb_norm.get(p, 0.0)
-                                  + w_ph * ph_norm.get(p, 0.0)
-                                  + w_im * im_norm.get(p, 0.0))
-
-        top_weighted = sorted(weighted_scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
-
-        # Method B: Rank-sum (Borda)
-        def ranks_from_map(m_norm):
-            items = sorted(m_norm.items(), key=lambda x: x[1], reverse=True)
-            ranks = {}
-            for i, (p, _) in enumerate(items):
-                ranks[p] = i + 1  # 1-based
-            worst = len(items) + 1
-            for p in all_paths:
-                if p not in ranks:
-                    ranks[p] = worst
-            return ranks
-
-        rank_emb = ranks_from_map(emb_norm)
-        rank_ph  = ranks_from_map(ph_norm)
-        rank_im  = ranks_from_map(im_norm)
-
-        rank_sum = {}
-        for p in all_paths:
-            rank_sum[p] = rank_emb.get(p, 9999) + rank_ph.get(p, 9999) + rank_im.get(p, 9999)
-        top_rank_sum = sorted(rank_sum.items(), key=lambda x: x[1])[:top_k]  # smaller is better
-
-        # Method C: Harmonic mean
-        harm_scores = {}
-        for p in all_paths:
-            a = emb_norm.get(p, 0.0)
-            b = ph_norm.get(p, 0.0)
-            c = im_norm.get(p, 0.0)
-            if a + b + c == 0 or a == 0 or b == 0 or c == 0:
-                harm = 0.0
+            embedding_results, phash_results, imgmatch_results, combined_results = run_query_search_flow(
+                query_b64=sprite_b64_clean[i],
+                processed_dir=BLOCKS_DIR,
+                embeddings_dict=embedding_json,
+                hash_dict=hash_data,
+                signature_obj_map=sig_data,
+                gis=gis,
+                phash=phash,
+                MAX_PHASH_BITS=64,
+                k=5
+            )
+            # Call the advanced re-ranker
+            rerank_result = choose_top_candidates(embedding_results, phash_results, imgmatch_results,
+                                                top_k=top_k, method_weights=method_weights, verbose=True)
+            per_sprite_rerank_debug.append(rerank_result)
+
+            # Selection logic: prefer consensus, else weighted top-1
+            final = None
+            if len(rerank_result["consensus_topk"]) > 0:
+                consensus = rerank_result["consensus_topk"]
+                best = max(consensus, key=lambda p: rerank_result["weighted_scores_full"].get(p, 0.0))
+                final = best
             else:
-                harm = 3.0 / ((1.0/a) + (1.0/b) + (1.0/c))
-            harm_scores[p] = harm
-        top_harm = sorted(harm_scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
-
-        # Consensus set: items in top-K of each metric
-        def topk_set_by_map(m_norm, k=top_k):
-            return set([p for p,_ in sorted(m_norm.items(), key=lambda x: x[1], reverse=True)[:k]])
-        cons_set = topk_set_by_map(emb_norm, top_k) & topk_set_by_map(ph_norm, top_k) & topk_set_by_map(im_norm, top_k)
-
-        result = {
-            "emb_norm": emb_norm,
-            "ph_norm": ph_norm,
-            "im_norm": im_norm,
-            "weighted_topk": top_weighted,
-            "rank_sum_topk": top_rank_sum,
-            "harmonic_topk": top_harm,
-            "consensus_topk": list(cons_set),
-            "weighted_scores_full": weighted_scores,
-            "rank_sum_full": rank_sum,
-            "harmonic_full": harm_scores
-        }
-
-        if verbose:
-            print(f"\nTop by Weighted Average (weights emb,ph,img = {w_emb:.2f},{w_ph:.2f},{w_im:.2f}):")
-            for i,(p,s) in enumerate(result["weighted_topk"], start=1):
-                print(f" {i}. {p}  score={s:.4f}  emb={emb_norm.get(p,0):.3f} ph={ph_norm.get(p,0):.3f} im={im_norm.get(p,0):.3f}")
-
-            print("\nTop by Rank-sum (lower is better):")
-            for i,(p,s) in enumerate(result["rank_sum_topk"], start=1):
-                print(f" {i}. {p}  rank_sum={s}  emb_rank={rank_emb.get(p)} ph_rank={rank_ph.get(p)} img_rank={rank_im.get(p)}")
-
-            print("\nTop by Harmonic mean:")
-            for i,(p,s) in enumerate(result["harmonic_topk"], start=1):
-                print(f" {i}. {p}  harm={s:.4f}  emb={emb_norm.get(p,0):.3f} ph={ph_norm.get(p,0):.3f} im={im_norm.get(p,0):.3f}")
-
-            print(f"\nConsensus (in top-{top_k} of ALL metrics): {result['consensus_topk']}")
+                final = rerank_result["weighted_topk"][0][0] if rerank_result["weighted_topk"] else None
+
+            # Store index and score for downstream use
+            if final is not None and final in paths_list:
+                idx = paths_list.index(final)
+                score = rerank_result["weighted_scores_full"].get(final, 0.0)
+                per_sprite_final_indices.append([idx])
+                per_sprite_final_scores.append([score])
+                print(f"Sprite '{sprite_ids}' FINAL selected: {final} (index {idx}) score={score:.4f}")
+            else:
+                per_sprite_final_indices.append([])
+                per_sprite_final_scores.append([])
 
-        # Final selection logic
-        final = None
-        if len(result["consensus_topk"]) > 0:
-            # Choose best-weighted among consensus
-            consensus = result["consensus_topk"]
-            best = max(consensus, key=lambda p: result["weighted_scores_full"].get(p, 0.0))
-            final = best
-        else:
-            final = result["weighted_topk"][0][0] if result["weighted_topk"] else None
+        return per_sprite_final_indices, per_sprite_final_scores, paths_list#, per_sprite_rerank_debug
 
-        result["final_selection"] = final
-        return result
-    
     # Use hybrid matching system
-    # BLOCKS_DIR = r"D:\DEV PATEL\2025\scratch_VLM\scratch_agent\blocks"
     per_sprite_matched_indices, per_sprite_scores, paths_list = hybrid_similarity_matching(
         sprite_images_bytes, sprite_ids, min_similarity, top_k, method_weights=(0.5, 0.3, 0.2)
     )
@@ -1839,78 +1866,47 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
     copied_sprite_folders = set()
     copied_backdrop_folders = set()
 
-    # Flatten unique matched indices to process copying once per folder
     matched_indices = sorted({idx for lst in per_sprite_matched_indices for idx in lst})
     print("matched_indices------------------>",matched_indices)
 
-    import shutil
-    import json
-    import os
-    from pathlib import Path
-    
-    # normalize base paths once before the loop
     sprite_base_p = Path(sprite_base_path).resolve(strict=False)
     backdrop_base_p = Path(backdrop_base_path).resolve(strict=False)
     project_folder_p = Path(project_folder)
     project_folder_p.mkdir(parents=True, exist_ok=True)
     
-    copied_sprite_folders = set()
-    copied_backdrop_folders = set()
-    
     def display_like_windows_no_lead(p: Path) -> str:
-        """
-        For human-readable logs only — convert Path to a string like:
-        "app\\blocks\\Backdrops\\Castle 2.sb3" (no leading slash).
-        """
-        s = p.as_posix()           # forward-slash string, safe for Path objects
+        s = p.as_posix()
         if s.startswith("/"):
             s = s[1:]
         return s.replace("/", "\\")
     
     def is_subpath(child: Path, parent: Path) -> bool:
-        """Robust membership test: is child under parent?"""
         try:
-            # use non-strict resolve only if needed, but avoid exceptions
             child.relative_to(parent)
             return True
         except Exception:
             return False
-    
-    # Flatten unique matched indices (if not already)
-    matched_indices = sorted({idx for lst in per_sprite_matched_indices for idx in lst})
-    print("matched_indices------------------>", matched_indices)
-    
+
+    # Copy assets and build project data (unchanged from your version)
     for matched_idx in matched_indices:
-        # defensive check
         if not (0 <= matched_idx < len(paths_list)):
             print(f"  ⚠ matched_idx {matched_idx} out of range, skipping")
             continue
-    
         matched_image_path = paths_list[matched_idx]
-        matched_path_p = Path(matched_image_path).resolve(strict=False)   # keep as Path
-        matched_folder_p = matched_path_p.parent                        # Path object
+        matched_path_p = Path(matched_image_path).resolve(strict=False)
+        matched_folder_p = matched_path_p.parent
         matched_filename = matched_path_p.name
-    
-        # Prepare display-only string (do NOT reassign matched_folder_p)
         matched_folder_display = display_like_windows_no_lead(matched_folder_p)
-    
         print(f"Processing matched image: {matched_image_path}")
         print(f"  - Folder: {matched_folder_display}")
-        print(f"  - Sprite path: {display_like_windows_no_lead(sprite_base_p)}")
-        print(f"  - Backdrop path: {display_like_windows_no_lead(backdrop_base_p)}")
-        print(f"  - Filename: {matched_filename}")
-    
-        # Use a canonical string to store in the copied set (POSIX absolute-ish)
+
         folder_key = matched_folder_p.as_posix()
-    
-        # ---------- SPRITE ----------
+
+        # SPRITE
         if is_subpath(matched_folder_p, sprite_base_p) and folder_key not in copied_sprite_folders:
             print(f"Processing SPRITE folder: {matched_folder_display}")
             copied_sprite_folders.add(folder_key)
-    
             sprite_json_path = matched_folder_p / "sprite.json"
-            print("sprite_json_path----------------------->", sprite_json_path)
-            print("copied sprite folder----------------------->", copied_sprite_folders)
             if sprite_json_path.exists() and sprite_json_path.is_file():
                 try:
                     with sprite_json_path.open("r", encoding="utf-8") as f:
@@ -1921,19 +1917,15 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
                     print(f"  ✗ Failed to read sprite.json in {matched_folder_display}: {repr(e)}")
             else:
                 print(f"  ⚠ No sprite.json in {matched_folder_display}")
-    
-            # copy non-matching files from the sprite folder (except matched image and sprite.json)
             try:
                 sprite_files = list(matched_folder_p.iterdir())
             except Exception as e:
                 sprite_files = []
                 print(f"  ✗ Failed to list files in {matched_folder_display}: {repr(e)}")
-    
             print(f"  Files in sprite folder: {[p.name for p in sprite_files]}")
             for p in sprite_files:
                 fname = p.name
                 if fname in (matched_filename, "sprite.json"):
-                    print(f"    Skipping {fname} (matched image or sprite.json)")
                     continue
                 if p.is_file():
                     dst = project_folder_p / fname
@@ -1942,17 +1934,11 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
                         print(f"    ✓ Copied sprite asset: {p} -> {dst}")
                     except Exception as e:
                         print(f"    ✗ Failed to copy sprite asset {p}: {repr(e)}")
-                else:
-                    print(f"    Skipping {fname} (not a file)")
-    
-        # ---------- BACKDROP ----------
+
+        # BACKDROP
         if is_subpath(matched_folder_p, backdrop_base_p) and folder_key not in copied_backdrop_folders:
             print(f"Processing BACKDROP folder: {matched_folder_display}")
             copied_backdrop_folders.add(folder_key)
-            print("backdrop_base_path----------------------->", display_like_windows_no_lead(backdrop_base_p))
-            print("copied backdrop folder----------------------->", copied_backdrop_folders)
-    
-            # copy matched backdrop image
             backdrop_src = matched_folder_p / matched_filename
             backdrop_dst = project_folder_p / matched_filename
             if backdrop_src.exists() and backdrop_src.is_file():
@@ -1963,19 +1949,15 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
                     print(f"  ✗ Failed to copy matched backdrop image {backdrop_src}: {repr(e)}")
             else:
                 print(f"  ⚠ Matched backdrop source not found: {backdrop_src}")
-    
-            # copy other files from folder (skip project.json and matched image)
             try:
                 backdrop_files = list(matched_folder_p.iterdir())
             except Exception as e:
                 backdrop_files = []
                 print(f"  ✗ Failed to list files in {matched_folder_display}: {repr(e)}")
-    
             print(f"  Files in backdrop folder: {[p.name for p in backdrop_files]}")
             for p in backdrop_files:
                 fname = p.name
                 if fname in (matched_filename, "project.json"):
-                    print(f"    Skipping {fname} (matched image or project.json)")
                     continue
                 if p.is_file():
                     dst = project_folder_p / fname
@@ -1984,28 +1966,18 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
                         print(f"    ✓ Copied backdrop asset: {p} -> {dst}")
                     except Exception as e:
                         print(f"    ✗ Failed to copy backdrop asset {p}: {repr(e)}")
-                else:
-                    print(f"    Skipping {fname} (not a file)")
-    
-            # read project.json to extract Stage/targets
             pj = matched_folder_p / "project.json"
             if pj.exists() and pj.is_file():
                 try:
                     with pj.open("r", encoding="utf-8") as f:
                         bd_json = json.load(f)
-                    stage_count = 0
                     for tgt in bd_json.get("targets", []):
                         if tgt.get("isStage"):
                             backdrop_data.append(tgt)
-                            stage_count += 1
-                    print(f"  ✓ Successfully read project.json from {matched_folder_display}, found {stage_count} stage(s)")
                 except Exception as e:
                     print(f"  ✗ Failed to read project.json in {matched_folder_display}: {repr(e)}")
-            else:
-                print(f"  ⚠ No project.json in {matched_folder_display}")
-    
-        print("---")
-        
+
+    # Final project JSON creation (same as your code)
     final_project = {
         "targets": [], "monitors": [], "extensions": [],
         "meta": {
@@ -2014,25 +1986,18 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
             "agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
         }
     }
-
-    
-    # Add sprite targets (non-stage)
     for spr in project_data:
         if not spr.get("isStage", False):
             final_project["targets"].append(spr)
-
-    # then backdrop as the Stage
     if backdrop_data:
         all_costumes, sounds = [], []
         seen_costumes = set()
         for i, bd in enumerate(backdrop_data):
             for costume in bd.get("costumes", []):
-                # Create a unique key for the costume
                 key = (costume.get("name"), costume.get("assetId"))
                 if key not in seen_costumes:
                     seen_costumes.add(key)
                     all_costumes.append(costume)
-    
             if i == 0:
                 sounds = bd.get("sounds", [])
         stage_obj={
@@ -2059,18 +2024,15 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
         logger.warning("⚠️ No backdrop matched. Using default static backdrop.")
         default_backdrop_path = BACKDROP_DIR / "cd21514d0531fdffb22204e0ec5ed84a.svg"
         default_backdrop_name = "cd21514d0531fdffb22204e0ec5ed84a.svg"
-
         default_backdrop_sound = BACKDROP_DIR / "83a9787d4cb6f3b7632b4ddfebf74367.wav"
         default_backdrop_sound_name = "cd21514d0531fdffb22204e0ec5ed84a.svg"
         try:
             shutil.copy2(default_backdrop_path, os.path.join(project_folder, default_backdrop_name))
             logger.info(f"✅ Default backdrop copied to project: {default_backdrop_name}")
-
             shutil.copy2(default_backdrop_sound, os.path.join(project_folder, default_backdrop_sound_name))
             logger.info(f"✅ Default backdrop sound copied to project: {default_backdrop_sound_name}")
         except Exception as e:
             logger.error(f"❌ Failed to copy default backdrop: {e}")
-            
         stage_obj={
             "isStage": True,
             "name": "Stage",
@@ -2115,6 +2077,694 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
         json.dump(final_project, f, indent=2)
 
     return project_json_path
+# ''' It appends all the list and paths from json files and pick the best match's path'''
+# def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1, min_similarity: float = None) -> str:
+#     print("🔍 Running similarity matching…")
+#     import os
+#     import json
+#     os.makedirs(project_folder, exist_ok=True)
+
+#     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")
+
+#     # -------------------------
+#     # Build sprite images list (BytesIO) from sprites_data
+#     # -------------------------
+#     sprite_ids, sprite_base64 = [], []
+#     for sid, sprite in sprites_data.items():
+#         sprite_ids.append(sid)
+#         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)
+
+#     # -----------------------------------------
+#     #  Hybrid Similarity Matching System
+#     # -----------------------------------------
+#     def hybrid_similarity_matching(sprite_images_bytes, sprite_ids, 
+#                                  min_similarity=None, top_k=5, method_weights=(0.5, 0.3, 0.2)):
+#         """
+#         Hybrid similarity matching using DINOv2 embeddings, perceptual hashing, and image signatures
+        
+#         Args:
+#             sprite_images_bytes: List of image bytes
+#             sprite_ids: List of sprite identifiers
+#             blocks_dir: Directory containing reference blocks
+#             min_similarity: Minimum similarity threshold
+#             top_k: Number of top matches to return
+#             method_weights: Weights for (embedding, phash, image_signature) methods
+            
+#         Returns:
+#             per_sprite_matched_indices, per_sprite_scores, paths_list
+#         """
+#         import imagehash as phash
+#         from image_match.goldberg import ImageSignature
+#         import math
+#         from collections import defaultdict
+        
+#         # Load reference data
+#         embeddings_path = os.path.join(BLOCKS_DIR, "hybrid_embeddings.json")
+#         hash_path = os.path.join(BLOCKS_DIR, "phash_data.json") 
+#         signature_path = os.path.join(BLOCKS_DIR, "signature_data.json")
+        
+#         # Load embeddings
+#         with open(embeddings_path, "r", encoding="utf-8") as f:
+#             embedding_json = json.load(f)
+            
+#         # Load phash data (if exists)
+#         hash_dict = {}
+#         if os.path.exists(hash_path):
+#             with open(hash_path, "r", encoding="utf-8") as f:
+#                 hash_data = json.load(f)
+#                 for path, hash_str in hash_data.items():
+#                     try:
+#                         hash_dict[path] = phash.hex_to_hash(hash_str)
+#                     except:
+#                         pass
+        
+#         # Load signature data (if exists)
+#         signature_dict = {}
+#         gis = ImageSignature()
+#         if os.path.exists(signature_path):
+#             with open(signature_path, "r", encoding="utf-8") as f:
+#                 sig_data = json.load(f)
+#                 for path, sig_list in sig_data.items():
+#                     try:
+#                         signature_dict[path] = np.array(sig_list)
+#                     except:
+#                         pass
+        
+#         # Parse embeddings
+#         paths_list = []
+#         embeddings_list = []
+        
+#         if isinstance(embedding_json, dict):
+#             for p, emb in embedding_json.items():
+#                 if isinstance(emb, dict):
+#                     maybe_emb = emb.get("embedding") or emb.get("embeddings") or emb.get("emb")
+#                     if maybe_emb is None:
+#                         continue
+#                     arr = np.asarray(maybe_emb, dtype=np.float32)
+#                 elif isinstance(emb, list):
+#                     arr = np.asarray(emb, dtype=np.float32)
+#                 else:
+#                     continue
+#                 paths_list.append(os.path.normpath(str(p)))
+#                 embeddings_list.append(arr)
+#         elif isinstance(embedding_json, list):
+#             for item in embedding_json:
+#                 if not isinstance(item, dict):
+#                     continue
+#                 p = item.get("path") or item.get("image_path") or item.get("file") or item.get("filename") or item.get("img_path")
+#                 emb = item.get("embeddings") or item.get("embedding") or item.get("features") or item.get("vector") or item.get("emb")
+#                 if p is None or emb is None:
+#                     continue
+#                 paths_list.append(os.path.normpath(str(p)))
+#                 embeddings_list.append(np.asarray(emb, dtype=np.float32))
+        
+#         if len(paths_list) == 0:
+#             raise RuntimeError("No reference images/embeddings found")
+            
+#         ref_matrix = np.vstack(embeddings_list).astype(np.float32)
+        
+#         # Process input sprites
+#         # init_dinov2()
+#         per_sprite_matched_indices = []
+#         per_sprite_scores = []
+        
+#         for i, (sprite_bytes, sprite_id) in enumerate(zip(sprite_images_bytes, sprite_ids)):
+#             print(f"Processing sprite {i+1}/{len(sprite_ids)}: {sprite_id}")
+            
+#             # Convert bytes to PIL for processing
+#             sprite_pil = Image.open(sprite_bytes)
+#             if sprite_pil is None:
+#                 per_sprite_matched_indices.append([])
+#                 per_sprite_scores.append([])
+#                 continue
+                
+#             # Enhance image
+#             enhanced_sprite = process_image_cv2_from_pil(sprite_pil, scale=2)
+#             if enhanced_sprite is None:
+#                 enhanced_sprite = sprite_pil
+            
+#             # 1. Compute DINOv2 embedding
+#             sprite_emb = get_dinov2_embedding_from_pil(preprocess_for_model(enhanced_sprite))
+#             if sprite_emb is None:
+#                 sprite_emb = np.zeros(ref_matrix.shape[1])
+            
+#             # 2. Compute perceptual hash
+#             sprite_hash_arr = preprocess_for_hash(enhanced_sprite)
+#             sprite_phash = None
+#             if sprite_hash_arr is not None:
+#                 try:
+#                     sprite_phash = phash.encode_image(image_array=sprite_hash_arr)
+#                 except:
+#                     pass
+            
+#             # 3. Compute image signature
+#             sprite_sig = None
+#             try:
+#                 temp_path = f"temp_sprite_{i}.png"
+#                 enhanced_sprite.save(temp_path, format="PNG")
+#                 sprite_sig = gis.generate_signature(temp_path)
+#                 os.remove(temp_path)
+#             except:
+#                 pass
+            
+#             # Calculate similarities for all reference images
+#             embedding_results = []
+#             phash_results = []
+#             signature_results = []
+            
+#             for j, ref_path in enumerate(paths_list):
+#                 # Embedding similarity
+#                 try:
+#                     ref_emb = ref_matrix[j]
+#                     emb_sim = float(np.dot(sprite_emb, ref_emb))
+#                     emb_sim = max(0.0, emb_sim)  # Clamp negative values
+#                 except:
+#                     emb_sim = 0.0
+#                 embedding_results.append((ref_path, emb_sim))
+                
+#                 # Phash similarity
+#                 ph_sim = 0.0
+#                 if sprite_phash is not None and ref_path in hash_dict:
+#                     try:
+#                         ref_hash = hash_dict[ref_path]
+#                         hd = phash.hamming_distance(sprite_phash, ref_hash)
+#                         ph_sim = max(0.0, 1.0 - (hd / 64.0))  # Normalize to [0,1]
+#                     except:
+#                         pass
+#                 phash_results.append((ref_path, ph_sim))
+                
+#                 # Signature similarity
+#                 sig_sim = 0.0
+#                 if sprite_sig is not None and ref_path in signature_dict:
+#                     try:
+#                         ref_sig = signature_dict[ref_path]
+#                         dist = gis.normalized_distance(ref_sig, sprite_sig)
+#                         sig_sim = max(0.0, 1.0 - dist)
+#                     except:
+#                         pass
+#                 signature_results.append((ref_path, sig_sim))
+            
+#             # Combine similarities using weighted approach
+#             def normalize_scores(scores):
+#                 """Normalize scores to [0,1] range"""
+#                 if not scores:
+#                     return {}
+#                 vals = [s for _, s in scores if not math.isnan(s)]
+#                 if not vals:
+#                     return {p: 0.0 for p, _ in scores}
+#                 vmin, vmax = min(vals), max(vals)
+#                 if vmax == vmin:
+#                     return {p: 1.0 if s == vmax else 0.0 for p, s in scores}
+#                 return {p: (s - vmin) / (vmax - vmin) for p, s in scores}
+            
+#             # Normalize each method's scores
+#             emb_norm = normalize_scores(embedding_results)
+#             ph_norm = normalize_scores(phash_results)
+#             sig_norm = normalize_scores(signature_results)
+            
+#             # Calculate weighted combined scores
+#             w_emb, w_ph, w_sig = method_weights
+#             combined_scores = []
+            
+#             for ref_path in paths_list:
+#                 combined_score = (w_emb * emb_norm.get(ref_path, 0.0) + 
+#                                 w_ph * ph_norm.get(ref_path, 0.0) + 
+#                                 w_sig * sig_norm.get(ref_path, 0.0))
+#                 combined_scores.append((ref_path, combined_score))
+            
+#             # Sort by combined score and apply thresholds
+#             combined_scores.sort(key=lambda x: x[1], reverse=True)
+            
+#             # Filter by minimum similarity if specified
+#             if min_similarity is not None:
+#                 combined_scores = [(p, s) for p, s in combined_scores if s >= float(min_similarity)]
+            
+#             # Get top-k matches
+#             top_matches = combined_scores[:int(top_k)]
+            
+#             # Convert to indices and scores
+#             matched_indices = []
+#             matched_scores = []
+            
+#             for ref_path, score in top_matches:
+#                 try:
+#                     idx = paths_list.index(ref_path)
+#                     matched_indices.append(idx)
+#                     matched_scores.append(score)
+#                 except ValueError:
+#                     continue
+            
+#             per_sprite_matched_indices.append(matched_indices)
+#             per_sprite_scores.append(matched_scores)
+            
+#             print(f"Sprite '{sprite_id}' matched {len(matched_indices)} references with scores: {matched_scores}")
+        
+#         return per_sprite_matched_indices, per_sprite_scores, paths_list
+    
+#     def choose_top_candidates_advanced(embedding_results, phash_results, imgmatch_results, top_k=10,
+#                               method_weights=(0.5, 0.3, 0.2), verbose=True):
+#         """
+#         Advanced candidate selection using multiple ranking methods
+        
+#         Args:
+#             embedding_results: list of (path, emb_sim)
+#             phash_results: list of (path, hamming, ph_sim) 
+#             imgmatch_results: list of (path, dist, im_sim)
+#             top_k: number of top candidates to return
+#             method_weights: weights for (emb, phash, imgmatch)
+#             verbose: whether to print detailed results
+            
+#         Returns:
+#             dict with top candidates from different methods and final selection
+#         """
+#         import math
+#         from collections import defaultdict
+        
+#         # Build dicts for quick lookup
+#         emb_map = {p: float(s) for p, s in embedding_results}
+#         ph_map = {p: float(sim) for p, _, sim in phash_results}
+#         im_map = {p: float(sim) for p, _, sim in imgmatch_results}
+
+#         # Universe of candidates (union)
+#         all_paths = sorted(set(list(emb_map.keys()) + list(ph_map.keys()) + list(im_map.keys())))
+
+#         # Normalize each metric across candidates to [0,1]
+#         def normalize_map(m):
+#             vals = [m.get(p, None) for p in all_paths]
+#             present = [v for v in vals if v is not None and not math.isnan(v)]
+#             if not present:
+#                 return {p: 0.0 for p in all_paths}
+#             vmin, vmax = min(present), max(present)
+#             if vmax == vmin:
+#                 return {p: (1.0 if (m.get(p, None) is not None) else 0.0) for p in all_paths}
+#             norm = {}
+#             for p in all_paths:
+#                 v = m.get(p, None)
+#                 if v is None or math.isnan(v):
+#                     norm[p] = 0.0
+#                 else:
+#                     norm[p] = max(0.0, min(1.0, (v - vmin) / (vmax - vmin)))
+#             return norm
+
+#         # For embeddings, clamp negatives to 0 first
+#         emb_map_clamped = {p: max(0.0, v) for p, v in emb_map.items()}
+
+#         emb_norm = normalize_map(emb_map_clamped)
+#         ph_norm  = normalize_map(ph_map)
+#         im_norm  = normalize_map(im_map)
+
+#         # Method A: Normalized weighted average
+#         w_emb, w_ph, w_im = method_weights
+#         weighted_scores = {}
+#         for p in all_paths:
+#             weighted_scores[p] = (w_emb * emb_norm.get(p, 0.0)
+#                                   + w_ph * ph_norm.get(p, 0.0)
+#                                   + w_im * im_norm.get(p, 0.0))
+
+#         top_weighted = sorted(weighted_scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
+
+#         # Method B: Rank-sum (Borda)
+#         def ranks_from_map(m_norm):
+#             items = sorted(m_norm.items(), key=lambda x: x[1], reverse=True)
+#             ranks = {}
+#             for i, (p, _) in enumerate(items):
+#                 ranks[p] = i + 1  # 1-based
+#             worst = len(items) + 1
+#             for p in all_paths:
+#                 if p not in ranks:
+#                     ranks[p] = worst
+#             return ranks
+
+#         rank_emb = ranks_from_map(emb_norm)
+#         rank_ph  = ranks_from_map(ph_norm)
+#         rank_im  = ranks_from_map(im_norm)
+
+#         rank_sum = {}
+#         for p in all_paths:
+#             rank_sum[p] = rank_emb.get(p, 9999) + rank_ph.get(p, 9999) + rank_im.get(p, 9999)
+#         top_rank_sum = sorted(rank_sum.items(), key=lambda x: x[1])[:top_k]  # smaller is better
+
+#         # Method C: Harmonic mean
+#         harm_scores = {}
+#         for p in all_paths:
+#             a = emb_norm.get(p, 0.0)
+#             b = ph_norm.get(p, 0.0)
+#             c = im_norm.get(p, 0.0)
+#             if a + b + c == 0 or a == 0 or b == 0 or c == 0:
+#                 harm = 0.0
+#             else:
+#                 harm = 3.0 / ((1.0/a) + (1.0/b) + (1.0/c))
+#             harm_scores[p] = harm
+#         top_harm = sorted(harm_scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
+
+#         # Consensus set: items in top-K of each metric
+#         def topk_set_by_map(m_norm, k=top_k):
+#             return set([p for p,_ in sorted(m_norm.items(), key=lambda x: x[1], reverse=True)[:k]])
+#         cons_set = topk_set_by_map(emb_norm, top_k) & topk_set_by_map(ph_norm, top_k) & topk_set_by_map(im_norm, top_k)
+
+#         result = {
+#             "emb_norm": emb_norm,
+#             "ph_norm": ph_norm,
+#             "im_norm": im_norm,
+#             "weighted_topk": top_weighted,
+#             "rank_sum_topk": top_rank_sum,
+#             "harmonic_topk": top_harm,
+#             "consensus_topk": list(cons_set),
+#             "weighted_scores_full": weighted_scores,
+#             "rank_sum_full": rank_sum,
+#             "harmonic_full": harm_scores
+#         }
+
+#         if verbose:
+#             print(f"\nTop by Weighted Average (weights emb,ph,img = {w_emb:.2f},{w_ph:.2f},{w_im:.2f}):")
+#             for i,(p,s) in enumerate(result["weighted_topk"], start=1):
+#                 print(f" {i}. {p}  score={s:.4f}  emb={emb_norm.get(p,0):.3f} ph={ph_norm.get(p,0):.3f} im={im_norm.get(p,0):.3f}")
+
+#             print("\nTop by Rank-sum (lower is better):")
+#             for i,(p,s) in enumerate(result["rank_sum_topk"], start=1):
+#                 print(f" {i}. {p}  rank_sum={s}  emb_rank={rank_emb.get(p)} ph_rank={rank_ph.get(p)} img_rank={rank_im.get(p)}")
+
+#             print("\nTop by Harmonic mean:")
+#             for i,(p,s) in enumerate(result["harmonic_topk"], start=1):
+#                 print(f" {i}. {p}  harm={s:.4f}  emb={emb_norm.get(p,0):.3f} ph={ph_norm.get(p,0):.3f} im={im_norm.get(p,0):.3f}")
+
+#             print(f"\nConsensus (in top-{top_k} of ALL metrics): {result['consensus_topk']}")
+
+#         # Final selection logic
+#         final = None
+#         if len(result["consensus_topk"]) > 0:
+#             # Choose best-weighted among consensus
+#             consensus = result["consensus_topk"]
+#             best = max(consensus, key=lambda p: result["weighted_scores_full"].get(p, 0.0))
+#             final = best
+#         else:
+#             final = result["weighted_topk"][0][0] if result["weighted_topk"] else None
+
+#         result["final_selection"] = final
+#         return result
+    
+#     # Use hybrid matching system
+#     # BLOCKS_DIR = r"D:\DEV PATEL\2025\scratch_VLM\scratch_agent\blocks"
+#     per_sprite_matched_indices, per_sprite_scores, paths_list = hybrid_similarity_matching(
+#         sprite_images_bytes, sprite_ids, min_similarity, top_k, method_weights=(0.5, 0.3, 0.2)
+#     )
+
+#     # =========================================
+#     #  Copy matched sprite assets + collect data
+#     # =========================================
+#     project_data   = []
+#     backdrop_data = []
+#     copied_sprite_folders = set()
+#     copied_backdrop_folders = set()
+
+#     # Flatten unique matched indices to process copying once per folder
+#     matched_indices = sorted({idx for lst in per_sprite_matched_indices for idx in lst})
+#     print("matched_indices------------------>",matched_indices)
+
+#     import shutil
+#     import json
+#     import os
+#     from pathlib import Path
+    
+#     # normalize base paths once before the loop
+#     sprite_base_p = Path(sprite_base_path).resolve(strict=False)
+#     backdrop_base_p = Path(backdrop_base_path).resolve(strict=False)
+#     project_folder_p = Path(project_folder)
+#     project_folder_p.mkdir(parents=True, exist_ok=True)
+    
+#     copied_sprite_folders = set()
+#     copied_backdrop_folders = set()
+    
+#     def display_like_windows_no_lead(p: Path) -> str:
+#         """
+#         For human-readable logs only — convert Path to a string like:
+#         "app\\blocks\\Backdrops\\Castle 2.sb3" (no leading slash).
+#         """
+#         s = p.as_posix()           # forward-slash string, safe for Path objects
+#         if s.startswith("/"):
+#             s = s[1:]
+#         return s.replace("/", "\\")
+    
+#     def is_subpath(child: Path, parent: Path) -> bool:
+#         """Robust membership test: is child under parent?"""
+#         try:
+#             # use non-strict resolve only if needed, but avoid exceptions
+#             child.relative_to(parent)
+#             return True
+#         except Exception:
+#             return False
+    
+#     # Flatten unique matched indices (if not already)
+#     matched_indices = sorted({idx for lst in per_sprite_matched_indices for idx in lst})
+#     print("matched_indices------------------>", matched_indices)
+    
+#     for matched_idx in matched_indices:
+#         # defensive check
+#         if not (0 <= matched_idx < len(paths_list)):
+#             print(f"  ⚠ matched_idx {matched_idx} out of range, skipping")
+#             continue
+    
+#         matched_image_path = paths_list[matched_idx]
+#         matched_path_p = Path(matched_image_path).resolve(strict=False)   # keep as Path
+#         matched_folder_p = matched_path_p.parent                        # Path object
+#         matched_filename = matched_path_p.name
+    
+#         # Prepare display-only string (do NOT reassign matched_folder_p)
+#         matched_folder_display = display_like_windows_no_lead(matched_folder_p)
+    
+#         print(f"Processing matched image: {matched_image_path}")
+#         print(f"  - Folder: {matched_folder_display}")
+#         print(f"  - Sprite path: {display_like_windows_no_lead(sprite_base_p)}")
+#         print(f"  - Backdrop path: {display_like_windows_no_lead(backdrop_base_p)}")
+#         print(f"  - Filename: {matched_filename}")
+    
+#         # Use a canonical string to store in the copied set (POSIX absolute-ish)
+#         folder_key = matched_folder_p.as_posix()
+    
+#         # ---------- SPRITE ----------
+#         if is_subpath(matched_folder_p, sprite_base_p) and folder_key not in copied_sprite_folders:
+#             print(f"Processing SPRITE folder: {matched_folder_display}")
+#             copied_sprite_folders.add(folder_key)
+    
+#             sprite_json_path = matched_folder_p / "sprite.json"
+#             print("sprite_json_path----------------------->", sprite_json_path)
+#             print("copied sprite folder----------------------->", copied_sprite_folders)
+#             if sprite_json_path.exists() and sprite_json_path.is_file():
+#                 try:
+#                     with sprite_json_path.open("r", encoding="utf-8") as f:
+#                         sprite_info = json.load(f)
+#                     project_data.append(sprite_info)
+#                     print(f"  ✓ Successfully read sprite.json from {matched_folder_display}")
+#                 except Exception as e:
+#                     print(f"  ✗ Failed to read sprite.json in {matched_folder_display}: {repr(e)}")
+#             else:
+#                 print(f"  ⚠ No sprite.json in {matched_folder_display}")
+    
+#             # copy non-matching files from the sprite folder (except matched image and sprite.json)
+#             try:
+#                 sprite_files = list(matched_folder_p.iterdir())
+#             except Exception as e:
+#                 sprite_files = []
+#                 print(f"  ✗ Failed to list files in {matched_folder_display}: {repr(e)}")
+    
+#             print(f"  Files in sprite folder: {[p.name for p in sprite_files]}")
+#             for p in sprite_files:
+#                 fname = p.name
+#                 if fname in (matched_filename, "sprite.json"):
+#                     print(f"    Skipping {fname} (matched image or sprite.json)")
+#                     continue
+#                 if p.is_file():
+#                     dst = project_folder_p / fname
+#                     try:
+#                         shutil.copy2(str(p), str(dst))
+#                         print(f"    ✓ Copied sprite asset: {p} -> {dst}")
+#                     except Exception as e:
+#                         print(f"    ✗ Failed to copy sprite asset {p}: {repr(e)}")
+#                 else:
+#                     print(f"    Skipping {fname} (not a file)")
+    
+#         # ---------- BACKDROP ----------
+#         if is_subpath(matched_folder_p, backdrop_base_p) and folder_key not in copied_backdrop_folders:
+#             print(f"Processing BACKDROP folder: {matched_folder_display}")
+#             copied_backdrop_folders.add(folder_key)
+#             print("backdrop_base_path----------------------->", display_like_windows_no_lead(backdrop_base_p))
+#             print("copied backdrop folder----------------------->", copied_backdrop_folders)
+    
+#             # copy matched backdrop image
+#             backdrop_src = matched_folder_p / matched_filename
+#             backdrop_dst = project_folder_p / matched_filename
+#             if backdrop_src.exists() and backdrop_src.is_file():
+#                 try:
+#                     shutil.copy2(str(backdrop_src), str(backdrop_dst))
+#                     print(f"  ✓ Copied matched backdrop image: {backdrop_src} -> {backdrop_dst}")
+#                 except Exception as e:
+#                     print(f"  ✗ Failed to copy matched backdrop image {backdrop_src}: {repr(e)}")
+#             else:
+#                 print(f"  ⚠ Matched backdrop source not found: {backdrop_src}")
+    
+#             # copy other files from folder (skip project.json and matched image)
+#             try:
+#                 backdrop_files = list(matched_folder_p.iterdir())
+#             except Exception as e:
+#                 backdrop_files = []
+#                 print(f"  ✗ Failed to list files in {matched_folder_display}: {repr(e)}")
+    
+#             print(f"  Files in backdrop folder: {[p.name for p in backdrop_files]}")
+#             for p in backdrop_files:
+#                 fname = p.name
+#                 if fname in (matched_filename, "project.json"):
+#                     print(f"    Skipping {fname} (matched image or project.json)")
+#                     continue
+#                 if p.is_file():
+#                     dst = project_folder_p / fname
+#                     try:
+#                         shutil.copy2(str(p), str(dst))
+#                         print(f"    ✓ Copied backdrop asset: {p} -> {dst}")
+#                     except Exception as e:
+#                         print(f"    ✗ Failed to copy backdrop asset {p}: {repr(e)}")
+#                 else:
+#                     print(f"    Skipping {fname} (not a file)")
+    
+#             # read project.json to extract Stage/targets
+#             pj = matched_folder_p / "project.json"
+#             if pj.exists() and pj.is_file():
+#                 try:
+#                     with pj.open("r", encoding="utf-8") as f:
+#                         bd_json = json.load(f)
+#                     stage_count = 0
+#                     for tgt in bd_json.get("targets", []):
+#                         if tgt.get("isStage"):
+#                             backdrop_data.append(tgt)
+#                             stage_count += 1
+#                     print(f"  ✓ Successfully read project.json from {matched_folder_display}, found {stage_count} stage(s)")
+#                 except Exception as e:
+#                     print(f"  ✗ Failed to read project.json in {matched_folder_display}: {repr(e)}")
+#             else:
+#                 print(f"  ⚠ No project.json in {matched_folder_display}")
+    
+#         print("---")
+        
+#     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"
+#         }
+#     }
+
+    
+#     # Add sprite targets (non-stage)
+#     for spr in project_data:
+#         if not spr.get("isStage", False):
+#             final_project["targets"].append(spr)
+
+#     # then backdrop as the Stage
+#     if backdrop_data:
+#         all_costumes, sounds = [], []
+#         seen_costumes = set()
+#         for i, bd in enumerate(backdrop_data):
+#             for costume in bd.get("costumes", []):
+#                 # Create a unique key for the costume
+#                 key = (costume.get("name"), costume.get("assetId"))
+#                 if key not in seen_costumes:
+#                     seen_costumes.add(key)
+#                     all_costumes.append(costume)
+    
+#             if i == 0:
+#                 sounds = bd.get("sounds", [])
+#         stage_obj={
+#             "isStage": True,
+#             "name": "Stage",
+#             "objName": "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
+#         }
+#         final_project["targets"].insert(0, stage_obj)
+#     else:
+#         logger.warning("⚠️ No backdrop matched. Using default static backdrop.")
+#         default_backdrop_path = BACKDROP_DIR / "cd21514d0531fdffb22204e0ec5ed84a.svg"
+#         default_backdrop_name = "cd21514d0531fdffb22204e0ec5ed84a.svg"
+
+#         default_backdrop_sound = BACKDROP_DIR / "83a9787d4cb6f3b7632b4ddfebf74367.wav"
+#         default_backdrop_sound_name = "cd21514d0531fdffb22204e0ec5ed84a.svg"
+#         try:
+#             shutil.copy2(default_backdrop_path, os.path.join(project_folder, default_backdrop_name))
+#             logger.info(f"✅ Default backdrop copied to project: {default_backdrop_name}")
+
+#             shutil.copy2(default_backdrop_sound, os.path.join(project_folder, default_backdrop_sound_name))
+#             logger.info(f"✅ Default backdrop sound copied to project: {default_backdrop_sound_name}")
+#         except Exception as e:
+#             logger.error(f"❌ Failed to copy default backdrop: {e}")
+            
+#         stage_obj={
+#             "isStage": True,
+#             "name": "Stage",
+#             "objName": "Stage",
+#             "variables": {},
+#             "lists": {},
+#             "broadcasts": {},
+#             "blocks": {},
+#             "comments": {},
+#             "currentCostume": 0,
+#             "costumes": [
+#                 {
+#                     "assetId": default_backdrop_name.split(".")[0],
+#                     "name": "defaultBackdrop",
+#                     "md5ext": default_backdrop_name,
+#                     "dataFormat": "svg",
+#                     "rotationCenterX": 240,
+#                     "rotationCenterY": 180
+#                 }
+#             ],
+#             "sounds": [
+#                 {
+#                 "name": "pop",
+#                 "assetId": "83a9787d4cb6f3b7632b4ddfebf74367",
+#                 "dataFormat": "wav",
+#                 "format": "",
+#                 "rate": 48000,
+#                 "sampleCount": 1123,
+#                 "md5ext": "83a9787d4cb6f3b7632b4ddfebf74367.wav"
+#                 }
+#             ],
+#             "volume": 100,
+#             "layerOrder": 0,
+#             "tempo": 60,
+#             "videoTransparency": 50,
+#             "videoState": "on",
+#             "textToSpeechLanguage": None
+#         }
+#         final_project["targets"].insert(0, stage_obj)
+
+#     with open(project_json_path, 'w') as f:
+#         json.dump(final_project, f, indent=2)
+
+#     return project_json_path
 
 
 def convert_pdf_stream_to_images(pdf_stream: io.BytesIO, dpi=300):