Update app.py

app.py

@@ -2,12 +2,14 @@ import gradio as gr
 import pytesseract
 from pytesseract import Output
 from PIL import Image
+import re
 
 def validate_chat_origin(image):
     if image is None:
         return {"valid": False, "error": "No image uploaded"}
 
     try:
+        # Get OCR Data with bounding boxes
         data = pytesseract.image_to_data(image, output_type=Output.DICT)
     except Exception as e:
         return {"valid": False, "error": str(e)}
@@ -15,102 +17,128 @@ def validate_chat_origin(image):
     img_w, img_h = image.size
     center_x = img_w / 2
     
-    # --- STEP 1: FIND THE HEADER BARRIER ---
-    # We look for keywords that mark the END of the profile header.
-    # The chat only starts BELOW these words.
-    barrier_keywords = ["block", "add to contacts", "report", "business account", "joined in", "not a contact"]
+    # --- STEP 1: DEFINE HEADER BARRIERS ---
+    # We look for words that ALWAYS appear in the header/profile section.
+    # The true chat (Hi, Hello, etc.) will always be BELOW these.
+    barrier_keywords = [
+        "block", "add to contacts", "report", "business account", 
+        "joined in", "not a contact", "encrypted", "end-to-end", 
+        "security code", "waiting for this message", "invite link",
+        "group", "created this group", "you're both in", "spam"
+    ]
     
+    # Regex to catch phone numbers (header info) like +94 71...
+    phone_pattern = re.compile(r'\+\d{2,3}\s?\d{2}')
+
+    # Find the LOWEST header element to set our "Safe Start Line"
     chat_start_y = 0
     
     n_boxes = len(data['text'])
     for i in range(n_boxes):
         text = data['text'][i].lower().strip()
-        if not text: continue
+        conf = int(data['conf'][i])
+        
+        if not text or conf < 30: continue
         
-        # If we find a barrier word, update the start position
-        if any(k in text for k in barrier_keywords):
-            # Set start Y to be 20px below this element
+        # Check if this word is a known header keyword
+        is_header_word = any(k in text for k in barrier_keywords)
+        
+        # Check if it looks like the profile phone number
+        is_phone = phone_pattern.search(text)
+        
+        if is_header_word or is_phone:
+            # We found a header element!
+            # The chat must start BELOW this element.
             element_bottom = data['top'][i] + data['height'][i]
+            
+            # Update our barrier to be the lowest one found so far
             if element_bottom > chat_start_y:
-                chat_start_y = element_bottom + 20
+                chat_start_y = element_bottom
 
-    # Fallback: If no "Block" button found (e.g. saved contact), skip top 20%
-    if chat_start_y == 0:
+    # Add a safety buffer (25px) below the lowest header element
+    if chat_start_y > 0:
+        chat_start_y += 25
+    else:
+        # Fallback: If OCR missed 'Block'/'Encrypted', skip top 20% of screen
         chat_start_y = img_h * 0.20
 
-    # --- STEP 2: ANALYZE LINES ---
+    # --- STEP 2: ANALYZE CHAT CONTENT ---
+    # Now we only look at text BELOW 'chat_start_y'
+    
     valid_lines = []
     
-    # Standard system words to ignore
-    ignore_words = ["today", "yesterday", "messages", "calls", "encrypted", "security", "code", "changed"]
+    # Words to ignore inside the chat area (System dates/info)
+    ignore_words = ["today", "yesterday", "unread", "messages", "calls"]
 
     for i in range(n_boxes):
         text = data['text'][i].strip()
         conf = int(data['conf'][i])
+        top = data['top'][i]
         
+        # FILTER A: Must be BELOW the calculated Header Barrier
+        if top < chat_start_y: 
+            continue
+            
+        # FILTER B: Ignore empty/low conf
         if not text or conf < 30: continue
         
-        # FILTER 1: Must be BELOW the Block/Profile section
-        if data['top'][i] < chat_start_y: continue
-        
-        # FILTER 2: Ignore system words
+        # FILTER C: Ignore common system words
         if any(w in text.lower() for w in ignore_words): continue
+        
+        # FILTER D: Ignore single symbols (OCR noise)
+        if len(text) == 1 and not text.isalnum(): continue
 
         valid_lines.append({
             "text": text,
             "left": data['left'][i],
-            "top": data['top'][i],
+            "top": top,
             "width": data['width'][i],
-            "height": data['height'][i]
+            "center": data['left'][i] + (data['width'][i] / 2)
         })
 
-    # Sort by Top position
+    # Sort lines Top-to-Bottom
     valid_lines.sort(key=lambda x: x['top'])
     
     final_decision = None
     debug_log = []
-    debug_log.append(f"Header Barrier set at Y={chat_start_y}")
+    debug_log.append(f"Header Barrier applied at Y={chat_start_y} (Ignored everything above)")
 
     for line in valid_lines:
-        # Calculate geometry
-        box_center = line["left"] + (line["width"] / 2)
-        deviation = abs(box_center - center_x)
-        
-        # --- CRITICAL FILTER: CENTER ALIGNMENT ---
-        # The name "Nithish" or dates like "20:18" (if centered) are NOT messages.
-        # If text is in the middle 20% of the screen, SKIP IT.
-        if deviation < (img_w * 0.10):
-            debug_log.append(f"Skipped CENTERED Text: '{line['text']}'")
+        # --- CHECK 1: CENTER ALIGNMENT ---
+        # If text is in the middle 15% of the screen, it's system text (Date/Info).
+        deviation = abs(line['center'] - center_x)
+        if deviation < (img_w * 0.15):
+            debug_log.append(f"Skipped CENTERED: '{line['text']}'")
             continue
             
-        # --- DECISION: LEFT vs RIGHT ---
-        # If we are here, the text is NOT centered. It must be a message.
+        # --- CHECK 2: LEFT vs RIGHT ---
+        # If we are here, text is NOT centered. It's a message.
         
-        # Stranger messages align to the Left (Start < 20% of screen)
-        if line["left"] < (img_w * 0.20):
+        # Stranger Limit: Starts within first 18% of screen
+        if line['left'] < (img_w * 0.18):
             final_decision = True
-            debug_log.append(f"✅ VALID (Stranger): '{line['text']}' is Left-Aligned.")
+            debug_log.append(f"✅ VALID (Stranger): '{line['text']}' found at Left Margin ({line['left']}px)")
             break
             
-        # Your messages align to the Right (Start > 40% of screen)
-        # OR they are far enough right to not be a stranger.
-        elif line["left"] > (img_w * 0.40):
+        # Me Limit: Starts after 40% of screen (safe assumption for right-aligned)
+        elif line['left'] > (img_w * 0.40):
             final_decision = False
-            debug_log.append(f"❌ INVALID (Me): '{line['text']}' is Right-Aligned.")
+            debug_log.append(f"❌ INVALID (Me): '{line['text']}' found at Right/Indented ({line['left']}px)")
             break
 
+    # --- FINAL OUTPUT ---
     if final_decision is True:
         return {"valid": True, "reason": "First message is from stranger.", "debug": debug_log}
     elif final_decision is False:
         return {"valid": False, "reason": "First message is from you.", "debug": debug_log}
     else:
-        return {"valid": False, "reason": "No clear chat text found.", "debug": debug_log}
+        return {"valid": False, "reason": "No valid chat messages found (Only system/header text).", "debug": debug_log}
 
 iface = gr.Interface(
     fn=validate_chat_origin,
     inputs=gr.Image(type="pil"),
     outputs=gr.JSON(),
-    title="WhatsApp Validator V10 (Barrier Logic)"
+    title="WhatsApp Validator V11 (Dynamic Barrier)"
 )
 
 if __name__ == "__main__":