added new parquet file

app.py

@@ -27,6 +27,8 @@ else:
 if DB_PATH:
     print(f"📂 Loaded Knowledge Base: {DB_PATH}")
     df_db = pd.read_parquet(DB_PATH)
+    print(f"📊 Database columns: {df_db.columns.tolist()}")
+    print(f"📊 Database shape: {df_db.shape}")
     # Convert embedding column to a clean numpy matrix for fast math
     DB_VECTORS = np.stack(df_db['embedding'].values)
     
@@ -34,6 +36,20 @@ if DB_PATH:
     # e.g. "famous_faces_GhostFaceNet.parquet" -> "GhostFaceNet"
     MODEL_NAME = DB_PATH.split("_")[-1].replace(".parquet", "")
     print(f"⚙️ Model configured: {MODEL_NAME}")
+    
+    # Debug: Check what directories exist
+    print(f"🔍 Checking available directories...")
+    if os.path.exists("my_dataset"):
+        files_in_dataset = os.listdir("my_dataset")[:5]  # Show first 5
+        print(f"   Found 'my_dataset' directory with {len(os.listdir('my_dataset'))} files")
+        print(f"   Sample files: {files_in_dataset}")
+    else:
+        print(f"   'my_dataset' directory not found")
+    
+    # Debug: Show sample image paths from database
+    if 'image_path' in df_db.columns:
+        sample_paths = df_db['image_path'].head(3).tolist()
+        print(f"📷 Sample image paths from DB: {sample_paths}")
 else:
     print("❌ CRITICAL: No Parquet file found! Please run the Model Battle step.")
     DB_VECTORS = None
@@ -41,49 +57,87 @@ else:
 
 # --- 2. Helper function to load images with fallbacks ---
 def load_image_with_fallback(image_path, name):
-    """Try to load image from various possible locations, or create placeholder"""
-    # Try original path
+    """
+    Try to load image from various possible locations, or create placeholder.
+    
+    The parquet file stores image_path (e.g., 'my_dataset/Sahar_Milis.png'),
+    but we need to find where the actual image files are located.
+    """
+    tried_paths = []
+    
+    # Strategy 1: Try original path as-is
     if os.path.exists(image_path):
         try:
-            return Image.open(image_path)
-        except:
-            pass
+            return Image.open(image_path), image_path
+        except Exception as e:
+            tried_paths.append(f"{image_path} (error: {e})")
+    else:
+        tried_paths.append(f"{image_path} (not found)")
     
-    # Try just the filename in current directory
+    # Strategy 2: Try just the filename in current directory
     filename = os.path.basename(image_path)
     if os.path.exists(filename):
         try:
-            return Image.open(filename)
-        except:
-            pass
+            return Image.open(filename), filename
+        except Exception as e:
+            tried_paths.append(f"{filename} (error: {e})")
+    else:
+        tried_paths.append(f"{filename} (not found)")
+    
+    # Strategy 3: Try in my_dataset directory (remove my_dataset/ prefix if present)
+    if image_path.startswith("my_dataset/"):
+        # Already has prefix, try as-is
+        dataset_path = image_path
+    else:
+        # Add prefix
+        dataset_path = os.path.join("my_dataset", filename)
     
-    # Try in my_dataset directory
-    dataset_path = os.path.join("my_dataset", filename)
     if os.path.exists(dataset_path):
         try:
-            return Image.open(dataset_path)
-        except:
-            pass
+            return Image.open(dataset_path), dataset_path
+        except Exception as e:
+            tried_paths.append(f"{dataset_path} (error: {e})")
+    else:
+        tried_paths.append(f"{dataset_path} (not found)")
+    
+    # Strategy 4: Try searching in current directory recursively
+    import glob
+    search_patterns = [
+        f"**/{filename}",
+        f"**/*{filename}",
+        f"**/{name.replace(' ', '_')}*",
+        f"**/{name.replace(' ', '-')}*",
+    ]
+    for pattern in search_patterns:
+        matches = glob.glob(pattern, recursive=True)
+        if matches:
+            try:
+                return Image.open(matches[0]), matches[0]
+            except:
+                continue
     
-    # Create a placeholder image if nothing found
+    # Strategy 5: Create a placeholder image with name
     placeholder = Image.new('RGB', (200, 200), color=(220, 220, 220))
     from PIL import ImageDraw, ImageFont
     draw = ImageDraw.Draw(placeholder)
     # Try to use default font, fallback to basic if not available
     try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 20)
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
     except:
         font = ImageFont.load_default()
     
-    # Draw text in center
-    text = f"Image\nNot Found"
-    bbox = draw.textbbox((0, 0), text, font=font)
-    text_width = bbox[2] - bbox[0]
-    text_height = bbox[3] - bbox[1]
-    position = ((200 - text_width) // 2, (200 - text_height) // 2)
-    draw.text(position, text, fill=(100, 100, 100), font=font)
+    # Draw name and "Not Found" text
+    text_lines = [name[:15], "Image", "Not Found"]
+    y_offset = 50
+    for line in text_lines:
+        bbox = draw.textbbox((0, 0), line, font=font)
+        text_width = bbox[2] - bbox[0]
+        position = ((200 - text_width) // 2, y_offset)
+        draw.text(position, line, fill=(100, 100, 100), font=font)
+        y_offset += 30
     
-    return placeholder
+    print(f"⚠️ Could not find image for {name}. Tried: {tried_paths[:3]}")
+    return placeholder, None
 
 # --- 3. Define the Search Logic ---
 def find_best_matches(user_image):
@@ -121,18 +175,59 @@ def find_best_matches(user_image):
             display_name = f"{row['name']} (Match: {int(score*100)}%)"
             result_text += f"### #{i}: {display_name}\n\n"
             
-            # Load Image with fallback - always add to gallery (with placeholder if needed)
+            # Load Image - prioritize bytes from parquet, then try file paths
             try:
-                img = load_image_with_fallback(row['image_path'], row['name'])
+                img = None
+                found_path = None
+                
+                # Strategy 1: Check if image is stored as bytes in parquet (BEST - self-contained)
+                if 'image_bytes' in df_db.columns and row.get('image_bytes') is not None:
+                    try:
+                        import io
+                        img = Image.open(io.BytesIO(row['image_bytes']))
+                        found_path = "parquet (embedded)"
+                    except Exception as e:
+                        print(f"⚠️ Could not load image bytes for {row['name']}: {e}")
+                
+                # Strategy 2: Try loading from file path (fallback)
+                if img is None and 'image_path' in df_db.columns:
+                    img, found_path = load_image_with_fallback(row['image_path'], row['name'])
+                
+                # Strategy 3: Create placeholder if still no image
+                if img is None:
+                    placeholder = Image.new('RGB', (200, 200), color=(220, 220, 220))
+                    from PIL import ImageDraw, ImageFont
+                    draw = ImageDraw.Draw(placeholder)
+                    try:
+                        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
+                    except:
+                        font = ImageFont.load_default()
+                    text_lines = [row['name'][:15], "Image", "Not Found"]
+                    y_offset = 50
+                    for line in text_lines:
+                        bbox = draw.textbbox((0, 0), line, font=font)
+                        text_width = bbox[2] - bbox[0]
+                        position = ((200 - text_width) // 2, y_offset)
+                        draw.text(position, line, fill=(100, 100, 100), font=font)
+                        y_offset += 30
+                    img = placeholder
+                    found_path = None
+                
                 gallery_images.append((img, display_name))
-                # Check if we used a placeholder
-                if not os.path.exists(row['image_path']) and not os.path.exists(os.path.basename(row['image_path'])):
-                    result_text += f"⚠️ Image not found at: {row['image_path']} (showing placeholder)\n\n"
+                
+                # Add status message
+                if found_path == "parquet (embedded)":
+                    result_text += f"✓ Image loaded from parquet\n\n"
+                elif found_path:
+                    result_text += f"✓ Found image at: {found_path}\n\n"
+                else:
+                    result_text += f"⚠️ Image not found for {row['name']}\n\n"
+                    
             except Exception as img_error:
                 # Even if loading fails, create placeholder
                 placeholder = Image.new('RGB', (200, 200), color=(220, 220, 220))
                 gallery_images.append((placeholder, display_name))
-                result_text += f"⚠️ Could not load image: {str(img_error)}\n\n"
+                result_text += f"⚠️ Error loading image: {str(img_error)}\n\n"
         
         # Don't pad with None - Gallery can't handle None images
         # Just return what we have

famous_faces_GhostFaceNet.parquet → famous_faces_ArcFace_standalone.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2683e1a44df3c686cd25fc73b922b46628702947e8c2ddef27083342e16c8beb
-size 3625095
+oid sha256:f5e212ec446c3014d737f327a5788deb262fcadd0bcee7c6052dda8a356727c4
+size 12055699