Update app.py

app.py

@@ -17,12 +17,15 @@ import torch.nn as nn
 import numpy as np
 import pandas as pd
 import joblib
+import smtplib
+import ssl
 import threading
 import uuid
 import time
 import requests
 import datetime
 from urllib.parse import urlparse
+from email.message import EmailMessage
 from flask import Flask, request, render_template, jsonify, Response, send_from_directory
 from werkzeug.utils import secure_filename
 
@@ -53,10 +56,11 @@ print("--- BOOT SEQUENCE INITIATED ---", flush=True)
 
 app = Flask(__name__)
 
-# --- HUGGING FACE SAFE SOS DISPATCH ---
-# Hugging Face blocks SMTP email ports (465, 587). 
-# We now use ntfy.sh to instantly send push notifications over standard HTTP (port 443).
-NTFY_TOPIC = "CrashVision_SOS_Alerts" 
+ALERT_EMAIL_SENDER = "gowreeshgowri50@gmail.com" 
+# FIX: Automatically strip spaces from Google App Password
+ALERT_EMAIL_PASSWORD = "oynu ulet pynk xsza".replace(" ", "") 
+ALERT_EMAIL_RECEIVER = "mcblackdevil12342@gmail.com"
+ENABLE_EMAIL_ALERTS = True
 
 UPLOAD_FOLDER = 'uploads'
 MODEL_FOLDER = 'models'
@@ -93,6 +97,7 @@ except:
     model_traffic = None
 
 # --- Helper Functions ---
+
 def get_geo_info(ip_or_url=None):
     """Fetches location and weather based on IP or URL."""
     try:
@@ -125,27 +130,40 @@ def process_accident_async(stream_id, frame, location, confidence, severity):
     if stream_id in active_streams:
         active_streams[stream_id]["plates"] = detected_plates
 
-    # --- HTTP PUSH NOTIFICATION DISPATCH (GUARANTEED TO WORK ON HF) ---
+    # --- FOOLPROOF PUSH NOTIFICATION (Bypasses HuggingFace SMTP Blocks) ---
     try:
-        _, buffer = cv2.imencode('.jpg', frame)
-        
+        ntfy_url = "https://ntfy.sh/crashvision_sos_alerts"
         headers = {
             "Title": f"🚨 {severity.upper()} ACCIDENT DETECTED",
-            "Priority": "5", # Highest priority, rings phone
-            "Tags": "rotating_light,car",
-            "Filename": "incident.jpg"
+            "Priority": "high",
+            "Tags": "warning,rotating_light,car"
         }
-        
-        # This sends the snapshot directly to ntfy.sh bypassing all email blocks
-        res = requests.post(
-            f"https://ntfy.sh/{NTFY_TOPIC}",
-            data=buffer.tobytes(),
-            headers=headers,
-            timeout=10
-        )
-        print(f"📡 Push Notification Sent via ntfy.sh/{NTFY_TOPIC} - HTTP {res.status_code}", flush=True)
+        msg_body = f"Location: {location}\nSeverity: {severity.capitalize()}\nConfidence: {confidence}%\nTime: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        requests.post(ntfy_url, data=msg_body.encode('utf-8'), headers=headers, timeout=5)
+        print("📱 Push Notification SOS sent via ntfy.sh!", flush=True)
     except Exception as e:
-        print(f"📡 SOS Dispatch Failed: {str(e)}", flush=True)
+        print(f"📱 Push Notification Failed: {e}", flush=True)
+
+    # --- EMAIL FALLBACK ---
+    if ENABLE_EMAIL_ALERTS:
+        try:
+            _, buffer = cv2.imencode('.jpg', frame)
+            msg = EmailMessage()
+            msg['Subject'] = f"🚨 ALERT: {severity.upper()} ACCIDENT DETECTED"
+            msg['From'] = ALERT_EMAIL_SENDER
+            msg['To'] = ALERT_EMAIL_RECEIVER
+            msg.set_content(f"Incident Report\nLocation: {location}\nSeverity: {severity}\nConfidence: {confidence}%\nTime: {datetime.datetime.now()}\n\nSystem has locked this stream for investigation.")
+            
+            msg.add_attachment(buffer.tobytes(), maintype='image', subtype='jpeg', filename='incident.jpg')
+            
+            context = ssl.create_default_context()
+            with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context, timeout=15) as server:
+                server.login(ALERT_EMAIL_SENDER, ALERT_EMAIL_PASSWORD)
+                server.send_message(msg)
+            
+            print(f"📧 Dispatch Email Sent Successfully for Stream {stream_id}", flush=True)
+        except Exception as e:
+            print(f"📧 Email Failed to Send (Likely Cloud Firewall): {str(e)}", flush=True)
 
 def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_min, yolo_max_conf, raw_frame, location):
     state = active_streams.get(stream_id)
@@ -165,6 +183,7 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
             confidence = float(ensemble_probs[final_idx] * 100)
             severity = classes[final_idx]
         except:
+            # Fallback if SVM isn't perfectly aligned
             final_idx = min(int(np.argmax(prob_max)), 2)
             confidence = float(np.max(prob_max)) * 100
             severity = classes[final_idx]
@@ -174,7 +193,7 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
         state["cnn"] = round(yolo_max_conf, 1)
         state["rcnn"] = round(float(np.max(prob_3d)) * 100, 1)
 
-        # Triggers the SOS webhook if confidence is high
+        # Lock the decision only if confidence crosses threshold (Lowered to 75 to ensure triggers)
         if confidence > 75:
             state["final_decision"] = True
             state["label"] = f"Incident Logged: {severity.capitalize()}"
@@ -184,10 +203,12 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
 
     except Exception as e:
         print(f"AI Error in Analysis Thread: {e}", flush=True)
+        traceback.print_exc()
     finally:
         if state: state["is_analyzing"] = False
 
 # --- Route Handlers ---
+
 @app.route('/init_upload', methods=['POST'])
 def init_upload():
     file = request.files['file']
@@ -200,7 +221,7 @@ def init_upload():
     active_streams[stream_id] = {
         "label": "Initializing...", "final_decision": False, "confidence": 0, "severity": "--", 
         "plates": [], "show_tracking": True, "paused": False, "seek_to": None, "skip_val": 0, "progress": 0,
-        "cnn": 0, "rcnn": 0
+        "cnn": 0, "rcnn": 0, "force_update": False
     }
     return jsonify({"stream_id": stream_id, "location": loc, "weather": wx, "time": file_time})
 
@@ -208,13 +229,16 @@ def init_upload():
 def init_stream():
     url = request.json.get('url')
     
-    # --- YouTube Live Stream Extraction ---
+    # --- YouTube Live Stream Resolution ---
     if 'youtube.com' in url or 'youtu.be' in url:
         try:
-            ydl_opts = {'format': 'best', 'quiet': True, 'noplaylist': True}
+            ydl_opts = {'format': 'best[ext=mp4]/best/bestvideo', 'quiet': True, 'noplaylist': True}
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 info = ydl.extract_info(url, download=False)
-                url = info.get('url', url)
+                if 'url' in info:
+                    url = info['url']
+                elif 'formats' in info and len(info['formats']) > 0:
+                    url = info['formats'][-1]['url']
         except Exception as e:
             print(f"yt-dlp extraction failed: {e}", flush=True)
 
@@ -225,7 +249,7 @@ def init_stream():
     active_streams[stream_id] = {
         "label": "Connecting...", "final_decision": False, "confidence": 0, "severity": "--", 
         "plates": [], "show_tracking": True, "paused": False, "seek_to": None, "skip_val": 0, "progress": 0,
-        "cnn": 0, "rcnn": 0
+        "cnn": 0, "rcnn": 0, "force_update": False
     }
     return jsonify({"stream_id": stream_id, "location": loc, "weather": wx, "time": v_time})
 
@@ -236,9 +260,9 @@ def video_control(stream_id):
     if not state: return jsonify({"error": "not found"}), 404
     
     action = request.json.get('action')
-    # Strict boolean casting to fix the toggle bug
     if action == 'toggle_tracking': 
-        state["show_tracking"] = True if request.json.get("track") else False
+        state["show_tracking"] = request.json.get("track", True)
+        state["force_update"] = True # Force frame redraw even if paused
     elif action == 'pause': state["paused"] = True
     elif action == 'play': state["paused"] = False
     elif action == 'seek': state["seek_to"] = request.json.get("value", 0.0)
@@ -257,6 +281,7 @@ def video_stream_gen(stream_id, source, location):
     yolo_probs = []
     frame_count = 0
     last_buffer = None
+    retry_count = 0
 
     if stream_id in active_streams:
         active_streams[stream_id]["label"] = "Scanning Stream..."
@@ -272,15 +297,21 @@ def video_stream_gen(stream_id, source, location):
             target = current_frame + (state['skip_val'] * fps)
             cap.set(cv2.CAP_PROP_POS_FRAMES, max(0, min(target, total_frames - 1)))
             state['skip_val'] = 0
-            frames_3d.clear(); yolo_probs.clear()
+            frames_3d.clear()
+            yolo_probs.clear()
             force_read = True
 
         if state.get('seek_to') is not None:
             target = int(state['seek_to'] * total_frames)
             cap.set(cv2.CAP_PROP_POS_FRAMES, target)
             state['seek_to'] = None
-            frames_3d.clear(); yolo_probs.clear()
+            frames_3d.clear()
+            yolo_probs.clear()
+            force_read = True
+            
+        if state.get('force_update'):
             force_read = True
+            state['force_update'] = False
 
         if state.get('paused') and not force_read:
             time.sleep(0.1)
@@ -290,65 +321,75 @@ def video_stream_gen(stream_id, source, location):
         loop_start = time.time()
         ret, frame = cap.read()
         
-        # --- Handle Stream End, Reconnections & Loops ---
         if not ret: 
-            if total_frames > 0: 
-                # Video File reached the end -> Auto-Loop
-                cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-                frames_3d.clear(); yolo_probs.clear()
+            if is_live:
+                retry_count += 1
+                if retry_count > 30: # Give up if IP cam is completely dead
+                    break
+                time.sleep(0.2)
                 continue
-            elif is_live:
-                # Live stream (or single snapshot URL) dropped -> Attempt Reconnect
-                cap.release()
-                time.sleep(0.5)
-                cap = cv2.VideoCapture(source)
+            elif total_frames > 0: 
+                # Auto-loop the video when it reaches the end for continuous replay
+                cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                frames_3d.clear()
+                yolo_probs.clear()
                 continue
             else:
                 break
+                
+        retry_count = 0 # reset on success
+        
+        # 🚨 FIX: Prevent High-Res IP Cams from OOM Crashing HuggingFace
+        h, w = frame.shape[:2]
+        if w > 1280:
+            frame = cv2.resize(frame, (1280, int(h * 1280 / w)))
 
         if total_frames > 0:
             state['progress'] = (cap.get(cv2.CAP_PROP_POS_FRAMES) / total_frames) * 100
-        else:
-            state['progress'] = 100 # Hide progress bar for live feeds
 
-        # Visualization Toggle
-        if state.get("show_tracking", True):
-            track_res = model_tracker(frame, classes=[2, 3, 5, 7], verbose=False, conf=0.3)[0]
-            display_frame = track_res.plot()
-        else:
-            # When tracking is false, we securely show the raw frame
+        # AI Tracking Visualization Layer
+        try:
+            if state.get("show_tracking", True):
+                track_res = model_tracker(frame, classes=[2, 3, 5, 7], verbose=False, conf=0.3)[0]
+                display_frame = track_res.plot()
+            else:
+                display_frame = frame
+        except Exception as e:
             display_frame = frame
 
-        # Brain Scanning
+        # Brain / Severity Scanning
         if not state.get("final_decision"):
-            res = model_yolo(frame, verbose=False)[0]
-            
-            probs = np.zeros(4)
-            if res.probs is not None:
-                data = res.probs.data.cpu().numpy()
-                length = min(len(data), 4)
-                probs[:length] = data[:length]
-            elif res.boxes is not None and len(res.boxes) > 0:
-                for box in res.boxes:
-                    cls_id = int(box.cls[0].item())
-                    if cls_id < 4: probs[cls_id] = max(probs[cls_id], float(box.conf[0].item()))
-            
-            yolo_probs.append(probs)
-            if len(yolo_probs) > 10: yolo_probs.pop(0)
-
-            f_3d = cv2.resize(frame, (112, 112))
-            frames_3d.append(cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB))
-            if len(frames_3d) > 16: frames_3d.pop(0)
-
-            if len(frames_3d) == 16 and frame_count % 10 == 0 and not state.get("is_analyzing"):
-                state["is_analyzing"] = True
-                p_max = np.max(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
-                p_mean = np.mean(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
-                p_min = np.min(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
+            try:
+                res = model_yolo(frame, verbose=False)[0]
+                
+                probs = np.zeros(4)
+                if res.probs is not None:
+                    data = res.probs.data.cpu().numpy()
+                    length = min(len(data), 4)
+                    probs[:length] = data[:length]
+                elif res.boxes is not None and len(res.boxes) > 0:
+                    for box in res.boxes:
+                        cls_id = int(box.cls[0].item())
+                        if cls_id < 4: probs[cls_id] = max(probs[cls_id], float(box.conf[0].item()))
                 
-                threading.Thread(target=run_temporal_analysis, args=(
-                    stream_id, list(frames_3d), p_max, p_mean, p_min, float(np.max(p_max))*100, frame.copy(), location
-                )).start()
+                yolo_probs.append(probs)
+                if len(yolo_probs) > 10: yolo_probs.pop(0)
+
+                f_3d = cv2.resize(frame, (112, 112))
+                frames_3d.append(cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB))
+                if len(frames_3d) > 16: frames_3d.pop(0)
+
+                if len(frames_3d) == 16 and frame_count % 10 == 0 and not state.get("is_analyzing"):
+                    state["is_analyzing"] = True
+                    p_max = np.max(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
+                    p_mean = np.mean(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
+                    p_min = np.min(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
+                    
+                    threading.Thread(target=run_temporal_analysis, args=(
+                        stream_id, list(frames_3d), p_max, p_mean, p_min, float(np.max(p_max))*100, frame.copy(), location
+                    )).start()
+            except Exception as e:
+                pass # Skip frame if AI crashes
 
         _, buffer = cv2.imencode('.jpg', display_frame)
         last_buffer = buffer.tobytes()