Update app.py

app.py

@@ -50,28 +50,6 @@ dinov2_model.eval()
 phash = PHash()
 gis = ImageSignature()
 
-def log_execution_time(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        start_time = time.time()
-        result = func(*args, **kwargs)
-        end_time = time.time()
-        logger.info(f"⏱ {func.__name__} executed in {end_time - start_time:.2f} seconds")
-        return result
-    return wrapper
-
-# Configure logging
-logging.basicConfig(
-    level=logging.DEBUG,  # Use INFO or ERROR in production
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    handlers=[
-        logging.FileHandler("/app/logs/app.log"),
-        logging.StreamHandler()
-    ]
-)
-
-logger = logging.getLogger(__name__)
-
 load_dotenv()
 # os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
 groq_api_key = os.getenv("GROQ_API_KEY")
@@ -84,26 +62,33 @@ llm = ChatGroq(
 
 app = Flask(__name__)
 
+backdrop_images_path = r"app\blocks\Backdrops"
+sprite_images_path = r"app\blocks\sprites"
+code_blocks_image_path = r"app\blocks\code_blocks"
+
 count = 0
 
-# BASE_DIR = Path("/app")
-# BLOCKS_DIR       = BASE_DIR / "blocks"
-# STATIC_DIR       = BASE_DIR / "static"
-# GEN_PROJECT_DIR  = BASE_DIR / "generated_projects"
+from pathlib import Path
 BASE_DIR = Path(os.getenv("APP_BASE_DIR", Path(__file__).resolve().parent))  # fallback to code location
-LOGS_DIR = BASE_DIR / "logs"
+LOGS_DIR = Path(os.getenv("LOGS_DIR", "/tmp/logs")).resolve()
+LOGS_DIR.mkdir(parents=True, exist_ok=True)
 for d in (BASE_DIR / "blocks", BASE_DIR / "static", BASE_DIR / "generated_projects", LOGS_DIR, BASE_DIR / "outputs"):
     d.mkdir(parents=True, exist_ok=True)
-BACKDROP_DIR     = BLOCKS_DIR / "Backdrops"
-SPRITE_DIR       = BLOCKS_DIR / "sprites"
-CODE_BLOCKS_DIR  = BLOCKS_DIR / "code_blocks"
-# === new: outputs rooted under BASE_DIR ===
-OUTPUT_DIR       = BASE_DIR / "outputs"
-
+# adjust BLOCKS_DIR etc:
+BLOCKS_DIR = BASE_DIR / "blocks"
+BACKDROP_DIR = BLOCKS_DIR / "Backdrops"
+SPRITE_DIR = BLOCKS_DIR / "sprites"
+CODE_BLOCKS_DIR = BLOCKS_DIR / "code_blocks"
 
-backdrop_images_path = str(BACKDROP_DIR)
-sprite_images_path = str(SPRITE_DIR)
-code_blocks_image_path = str(CODE_BLOCKS_DIR)
+# BASE_DIR = Path("/app")
+# BLOCKS_DIR       = BASE_DIR / "blocks"
+# STATIC_DIR       = BASE_DIR / "static"
+# GEN_PROJECT_DIR  = BASE_DIR / "generated_projects"
+# BACKDROP_DIR     = BLOCKS_DIR / "Backdrops"
+# SPRITE_DIR       = BLOCKS_DIR / "sprites"
+# CODE_BLOCKS_DIR  = BLOCKS_DIR / "code_blocks"
+# # === new: outputs rooted under BASE_DIR ===
+# OUTPUT_DIR       = BASE_DIR / "outputs"
 
 # Global variables to hold the model and index, loaded only once.
 MODEL = None
@@ -121,7 +106,30 @@ for d in (
     OUTPUT_DIR,
 ):
     d.mkdir(parents=True, exist_ok=True)
-      
+
+def log_execution_time(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        logger.info(f"⏱ {func.__name__} executed in {end_time - start_time:.2f} seconds")
+        return result
+    return wrapper
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[
+        logging.FileHandler(str(LOGS_DIR / "app.log")),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+    
 class GameState(TypedDict):
     project_json: dict
     description: str
@@ -1427,15 +1435,11 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
     import json
     os.makedirs(project_folder, exist_ok=True)
 
-    # backdrop_base_path = os.path.normpath(str(BACKDROP_DIR)).resolve()
-    # sprite_base_path   = os.path.normpath(str(SPRITE_DIR)).resolve()
-    # code_blocks_path = os.path.normpath(str(CODE_BLOCKS_DIR)).resolve()
-    # project_json_path = os.path.join(project_folder, "project.json").resolve()
-    backdrop_base_path = BACKDROP_DIR.resolve()
-    sprite_base_path   = SPRITE_DIR.resolve()
-    code_blocks_path   = CODE_BLOCKS_DIR.resolve()
-    project_json_path  = (Path(project_folder) / "project.json").resolve()
+    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
@@ -1944,272 +1948,265 @@ def similarity_matching(sprites_data: dict, project_folder: str, top_k: int = 1,
     
     #     print("---")
         # add at top of file
-    # 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)
+    import shutil
+    import json
+    import os
+    from pathlib import Path
     
-    #     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}")
+    # 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)
     
-    #     # Use a canonical string to store in the copied set (POSIX absolute-ish)
-    #     folder_key = matched_folder_p.as_posix()
+    copied_sprite_folders = set()
+    copied_backdrop_folders = set()
     
-    #     # ---------- 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)
+    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("/", "\\")
     
-    #         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}")
+    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
     
-    #         # 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)}")
+    # 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)
     
-    #         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)")
+    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
     
-    #     # ---------- 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)
+        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
     
-    #         # 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}")
+        # Prepare display-only string (do NOT reassign matched_folder_p)
+        matched_folder_display = display_like_windows_no_lead(matched_folder_p)
     
-    #         # 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"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}")
     
-    #         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)")
+        # Use a canonical string to store in the copied set (POSIX absolute-ish)
+        folder_key = matched_folder_p.as_posix()
     
-    #         # 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}")
+        # ---------- 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)
     
-    #     print("---")
-    for matched_idx in matched_indices:
-        matched_image_path = paths_list[matched_idx]
-        # matched_folder = os.path.dirname(matched_image_path)
-        matched_folder = str(Path(matched_image_path).parent.resolve())
-        matched_filename = os.path.basename(matched_image_path)
-        
-        print(f"Processing matched image: {matched_image_path}")
-        print(f"  - Folder: {matched_folder}")
-        print(f"  - Sprite path: {sprite_base_path}")
-        print(f"  - Backdrop path: {backdrop_base_path}")
-        print(f"  - Filename: {matched_filename}")
-        
-        # If it's a sprite (under SPRITE_DIR) -> copy sprite assets and read sprite.json
-        # if matched_folder.startswith(sprite_base_path) and matched_folder not in copied_sprite_folders:
-        if is_subpath(matched_folder, sprite_base_path) and matched_folder not in copied_sprite_folders:
-            print(f"Processing SPRITE folder: {matched_folder}")
-            copied_sprite_folders.add(matched_folder)
-            # sprite_json_path = os.path.join(matched_folder, "sprite.json")
-            sprite_json_path = str(Path(matched_folder) / "sprite.json")
-            print("sprite_json_path----------------------->",sprite_json_path)
-            print("copied sprite folder----------------------->",copied_sprite_folders)
-            if os.path.exists(sprite_json_path):
+            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 open(sprite_json_path, "r", encoding="utf-8") as f:
+                    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}")
+                    print(f"  ✓ Successfully read sprite.json from {matched_folder_display}")
                 except Exception as e:
-                    print(f"  ✗ Failed to read sprite.json in {matched_folder}: {e}")
+                    print(f"  ✗ Failed to read sprite.json in {matched_folder_display}: {repr(e)}")
             else:
-                print(f"  ⚠ No sprite.json in {matched_folder}")
-            
-            # copy non-matching files from the sprite folder (except the matched image and sprite.json)
-            sprite_files = os.listdir(matched_folder)
-            print(f"  Files in sprite folder: {sprite_files}")
-            for fname in sprite_files:
+                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
-                src = os.path.join(matched_folder, fname)
-                dst = os.path.join(project_folder, fname)
-                if os.path.isfile(src):
+                if p.is_file():
+                    dst = project_folder_p / fname
                     try:
-                        shutil.copy2(src, dst)
-                        print(f"    ✓ Copied sprite asset: {src} -> {dst}")
+                        shutil.copy2(str(p), str(dst))
+                        print(f"    ✓ Copied sprite asset: {p} -> {dst}")
                     except Exception as e:
-                        print(f"    ✗ Failed to copy sprite asset {src}: {e}")
+                        print(f"    ✗ Failed to copy sprite asset {p}: {repr(e)}")
                 else:
                     print(f"    Skipping {fname} (not a file)")
-
-        # If it's a backdrop (under BACKDROP_DIR) -> copy backdrop assets and read project.json for stage
-        # if matched_folder.startswith(backdrop_base_path) and matched_folder not in copied_backdrop_folders:
-        if is_subpath(matched_folder, backdrop_base_path) and matched_folder not in copied_backdrop_folders:
-            print(f"Processing BACKDROP folder: {matched_folder}")
-            copied_backdrop_folders.add(matched_folder)
-            print("backdrop_base_path----------------------->",backdrop_base_path)
-            print("copied backdrop folder----------------------->",copied_backdrop_folders)
+    
+        # ---------- 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_dst = os.path.join(project_folder, matched_filename)
+            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:
-                shutil.copy2(matched_image_path, backdrop_dst)
-                print(f"  ✓ Copied matched backdrop image: {matched_image_path} -> {backdrop_dst}")
+                backdrop_files = list(matched_folder_p.iterdir())
             except Exception as e:
-                print(f"  ✗ Failed to copy matched backdrop image {matched_image_path}: {e}")
-
-            # copy other files from folder (skip project.json and matched image)
-            backdrop_files = os.listdir(matched_folder)
-            print(f"  Files in backdrop folder: {backdrop_files}")
-            for fname in backdrop_files:
+                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
-                # src = os.path.join(matched_folder, fname)
-                # dst = os.path.join(project_folder, fname)
-                src = Path(matched_folder) / fname
-                dst = Path(project_folder) / fname
-                if os.path.isfile(src):
+                if p.is_file():
+                    dst = project_folder_p / fname
                     try:
-                        shutil.copy2(src, dst)
-                        print(f"    ✓ Copied backdrop asset: {src} -> {dst}")
+                        shutil.copy2(str(p), str(dst))
+                        print(f"    ✓ Copied backdrop asset: {p} -> {dst}")
                     except Exception as e:
-                        print(f"    ✗ Failed to copy backdrop asset {src}: {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 = os.path.join(matched_folder, "project.json")
-            pj = str(Path(matched_folder) / "project.json")
-            if os.path.exists(pj):
+            pj = matched_folder_p / "project.json"
+            if pj.exists() and pj.is_file():
                 try:
-                    with open(pj, "r", encoding="utf-8") as f:
+                    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}, found {stage_count} stage(s)")
+                    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}: {e}")
+                    print(f"  ✗ Failed to read project.json in {matched_folder_display}: {repr(e)}")
             else:
-                print(f"  ⚠ No project.json in {matched_folder}")
-        
+                print(f"  ⚠ No project.json in {matched_folder_display}")
+    
         print("---")
+    # for matched_idx in matched_indices:
+    #     matched_image_path = paths_list[matched_idx]
+    #     matched_folder = os.path.dirname(matched_image_path)
+    #     matched_filename = os.path.basename(matched_image_path)
+        
+    #     print(f"Processing matched image: {matched_image_path}")
+    #     print(f"  - Folder: {matched_folder}")
+    #     print(f"  - Sprite path: {sprite_base_path}")
+    #     print(f"  - Backdrop path: {backdrop_base_path}")
+    #     print(f"  - Filename: {matched_filename}")
+        
+    #     # If it's a sprite (under SPRITE_DIR) -> copy sprite assets and read sprite.json
+    #     if matched_folder.startswith(sprite_base_path) and matched_folder not in copied_sprite_folders:
+    #         print(f"Processing SPRITE folder: {matched_folder}")
+    #         copied_sprite_folders.add(matched_folder)
+    #         sprite_json_path = os.path.join(matched_folder, "sprite.json")
+    #         print("sprite_json_path----------------------->",sprite_json_path)
+    #         print("copied sprite folder----------------------->",copied_sprite_folders)
+    #         if os.path.exists(sprite_json_path):
+    #             try:
+    #                 with open(sprite_json_path, "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}")
+    #             except Exception as e:
+    #                 print(f"  ✗ Failed to read sprite.json in {matched_folder}: {e}")
+    #         else:
+    #             print(f"  ⚠ No sprite.json in {matched_folder}")
+            
+    #         # copy non-matching files from the sprite folder (except the matched image and sprite.json)
+    #         sprite_files = os.listdir(matched_folder)
+    #         print(f"  Files in sprite folder: {sprite_files}")
+    #         for fname in sprite_files:
+    #             if fname in (matched_filename, "sprite.json"):
+    #                 print(f"    Skipping {fname} (matched image or sprite.json)")
+    #                 continue
+    #             src = os.path.join(matched_folder, fname)
+    #             dst = os.path.join(project_folder, fname)
+    #             if os.path.isfile(src):
+    #                 try:
+    #                     shutil.copy2(src, dst)
+    #                     print(f"    ✓ Copied sprite asset: {src} -> {dst}")
+    #                 except Exception as e:
+    #                     print(f"    ✗ Failed to copy sprite asset {src}: {e}")
+    #             else:
+    #                 print(f"    Skipping {fname} (not a file)")
+
+    #     # If it's a backdrop (under BACKDROP_DIR) -> copy backdrop assets and read project.json for stage
+    #     if matched_folder.startswith(backdrop_base_path) and matched_folder not in copied_backdrop_folders:
+    #         print(f"Processing BACKDROP folder: {matched_folder}")
+    #         copied_backdrop_folders.add(matched_folder)
+    #         print("backdrop_base_path----------------------->",backdrop_base_path)
+    #         print("copied backdrop folder----------------------->",copied_backdrop_folders)
+    #         # copy matched backdrop image
+    #         backdrop_dst = os.path.join(project_folder, matched_filename)
+    #         try:
+    #             shutil.copy2(matched_image_path, backdrop_dst)
+    #             print(f"  ✓ Copied matched backdrop image: {matched_image_path} -> {backdrop_dst}")
+    #         except Exception as e:
+    #             print(f"  ✗ Failed to copy matched backdrop image {matched_image_path}: {e}")
+
+    #         # copy other files from folder (skip project.json and matched image)
+    #         backdrop_files = os.listdir(matched_folder)
+    #         print(f"  Files in backdrop folder: {backdrop_files}")
+    #         for fname in backdrop_files:
+    #             if fname in (matched_filename, "project.json"):
+    #                 print(f"    Skipping {fname} (matched image or project.json)")
+    #                 continue
+    #             src = os.path.join(matched_folder, fname)
+    #             dst = os.path.join(project_folder, fname)
+    #             if os.path.isfile(src):
+    #                 try:
+    #                     shutil.copy2(src, dst)
+    #                     print(f"    ✓ Copied backdrop asset: {src} -> {dst}")
+    #                 except Exception as e:
+    #                     print(f"    ✗ Failed to copy backdrop asset {src}: {e}")
+    #             else:
+    #                 print(f"    Skipping {fname} (not a file)")
+
+    #         # read project.json to extract Stage/targets
+    #         pj = os.path.join(matched_folder, "project.json")
+    #         if os.path.exists(pj):
+    #             try:
+    #                 with open(pj, "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}, found {stage_count} stage(s)")
+    #             except Exception as e:
+    #                 print(f"  ✗ Failed to read project.json in {matched_folder}: {e}")
+    #         else:
+    #             print(f"  ⚠ No project.json in {matched_folder}")
+        
+    #     print("---")
 
     # --- Merge into final Scratch project.json (identical logic to before)
     final_project = {