Update app.py

app.py

@@ -17,15 +17,12 @@ 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
 
@@ -56,11 +53,9 @@ print("--- BOOT SEQUENCE INITIATED ---", flush=True)
 
 app = Flask(__name__)
 
-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
+# --- HUGGING FACE SAFE SOS DISPATCH ---
+# We use ntfy.sh (HTTP Push) which is guaranteed to bypass Hugging Face email/SMTP blocks.
+NTFY_TOPIC = "CrashVision_SOS_Alerts" 
 
 UPLOAD_FOLDER = 'uploads'
 MODEL_FOLDER = 'models'
@@ -99,7 +94,6 @@ except:
 # --- Helper Functions ---
 
 def get_geo_info(ip_or_url=None):
-    """Fetches location and weather based on IP or URL."""
     try:
         target = ""
         if ip_or_url:
@@ -130,40 +124,19 @@ def process_accident_async(stream_id, frame, location, confidence, severity):
     if stream_id in active_streams:
         active_streams[stream_id]["plates"] = detected_plates
 
-    # --- FOOLPROOF PUSH NOTIFICATION (Bypasses HuggingFace SMTP Blocks) ---
+    # --- HTTP PUSH DISPATCH (Replaces Email on Hugging Face) ---
     try:
-        ntfy_url = "https://ntfy.sh/crashvision_sos_alerts"
+        _, buffer = cv2.imencode('.jpg', frame)
         headers = {
             "Title": f"🚨 {severity.upper()} ACCIDENT DETECTED",
-            "Priority": "high",
-            "Tags": "warning,rotating_light,car"
+            "Priority": "5",
+            "Tags": "rotating_light,car",
+            "Click": f"https://huggingface.co/spaces/{os.environ.get('SPACE_ID', '')}"
         }
-        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)
+        requests.post(f"https://ntfy.sh/{NTFY_TOPIC}", data=buffer.tobytes(), headers=headers, timeout=10)
+        print(f"📡 SOS Push dispatched to ntfy.sh/{NTFY_TOPIC}", flush=True)
     except Exception as e:
-        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)
+        print(f"📡 SOS Push failed: {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)
@@ -183,7 +156,6 @@ 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]
@@ -193,7 +165,6 @@ 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)
 
-        # 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()}"
@@ -202,8 +173,7 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
             state["label"] = f"Analyzing... ({severity.capitalize()})"
 
     except Exception as e:
-        print(f"AI Error in Analysis Thread: {e}", flush=True)
-        traceback.print_exc()
+        print(f"AI Error: {e}", flush=True)
     finally:
         if state: state["is_analyzing"] = False
 
@@ -229,16 +199,14 @@ def init_upload():
 def init_stream():
     url = request.json.get('url')
     
-    # --- YouTube Live Stream Resolution ---
+    # YouTube Link Extractor
     if 'youtube.com' in url or 'youtu.be' in url:
         try:
             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)
-                if 'url' in info:
-                    url = info['url']
-                elif 'formats' in info and len(info['formats']) > 0:
-                    url = info['formats'][-1]['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)
 
@@ -255,14 +223,13 @@ def init_stream():
 
 @app.route('/video_control/<stream_id>', methods=['POST'])
 def video_control(stream_id):
-    """Dynamic Video Controls for the AI Player"""
     state = active_streams.get(stream_id)
     if not state: return jsonify({"error": "not found"}), 404
     
     action = request.json.get('action')
     if action == 'toggle_tracking': 
-        state["show_tracking"] = request.json.get("track", True)
-        state["force_update"] = True # Force frame redraw even if paused
+        state["show_tracking"] = bool(request.json.get("track"))
+        state["force_update"] = True 
     elif action == 'pause': state["paused"] = True
     elif action == 'play': state["paused"] = False
     elif action == 'seek': state["seek_to"] = request.json.get("value", 0.0)
@@ -273,7 +240,7 @@ def video_control(stream_id):
 def video_stream_gen(stream_id, source, location):
     cap = cv2.VideoCapture(source)
     fps = cap.get(cv2.CAP_PROP_FPS)
-    if not fps or fps == 0: fps = 30.0
+    if not fps or fps == 0: fps = 25.0
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     is_live = str(source).startswith('http')
     
@@ -283,6 +250,10 @@ def video_stream_gen(stream_id, source, location):
     last_buffer = None
     retry_count = 0
 
+    # --- Real-Time Sync Engine (Forces original speed) ---
+    start_sync_time = time.time()
+    current_frame_idx = 0
+
     if stream_id in active_streams:
         active_streams[stream_id]["label"] = "Scanning Stream..."
 
@@ -293,20 +264,21 @@ def video_stream_gen(stream_id, source, location):
         force_read = False
 
         if state.get('skip_val', 0) != 0:
-            current_frame = cap.get(cv2.CAP_PROP_POS_FRAMES)
-            target = current_frame + (state['skip_val'] * fps)
-            cap.set(cv2.CAP_PROP_POS_FRAMES, max(0, min(target, total_frames - 1)))
+            target = max(0, min(current_frame_idx + (state['skip_val'] * fps), total_frames - 1))
+            cap.set(cv2.CAP_PROP_POS_FRAMES, target)
+            current_frame_idx = int(target)
+            start_sync_time = time.time() - (current_frame_idx / fps)
             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)
+            current_frame_idx = target
+            start_sync_time = time.time() - (current_frame_idx / fps)
             state['seek_to'] = None
-            frames_3d.clear()
-            yolo_probs.clear()
+            frames_3d.clear(); yolo_probs.clear()
             force_read = True
             
         if state.get('force_update'):
@@ -314,59 +286,63 @@ def video_stream_gen(stream_id, source, location):
             state['force_update'] = False
 
         if state.get('paused') and not force_read:
+            start_sync_time = time.time() - (current_frame_idx / fps) # Freeze timeline
             time.sleep(0.1)
             if last_buffer: yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + last_buffer + b'\r\n')
             continue
 
-        loop_start = time.time()
+        # --- Frameskipping to maintain exact 1x normal speed if AI lags ---
+        if not is_live and not force_read:
+            elapsed = time.time() - start_sync_time
+            target_frame = int(elapsed * fps)
+            frames_to_skip = target_frame - current_frame_idx
+            if frames_to_skip > 0:
+                for _ in range(min(frames_to_skip, 5)): # Cap skips to avoid locking CPU
+                    cap.grab()
+                    current_frame_idx += 1
+
         ret, frame = cap.read()
+        current_frame_idx += 1
         
         if not ret: 
-            if is_live:
+            if is_live: # Auto-Reconnect for dropped IP Cams
                 retry_count += 1
-                if retry_count > 30: # Give up if IP cam is completely dead
-                    break
-                time.sleep(0.2)
-                continue
-            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()
+                if retry_count > 30: break
+                cap.release(); time.sleep(0.5)
+                cap = cv2.VideoCapture(source); continue
+            elif total_frames > 0: # Auto-Loop
+                cap.set(cv2.CAP_PROP_POS_FRAMES, 0); current_frame_idx = 0
+                start_sync_time = time.time(); frames_3d.clear(); yolo_probs.clear()
                 continue
-            else:
-                break
+            else: break
+            
+        retry_count = 0
                 
-        retry_count = 0 # reset on success
-        
-        # 🚨 FIX: Prevent High-Res IP Cams from OOM Crashing HuggingFace
+        # Resize high-res streams to prevent Hugging Face OOM Memory crashes
         h, w = frame.shape[:2]
-        if w > 1280:
-            frame = cv2.resize(frame, (1280, int(h * 1280 / w)))
+        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
+            state['progress'] = (current_frame_idx / total_frames) * 100
 
-        # AI Tracking Visualization Layer
+        # Tracking Visualization Toggle
         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
+                display_frame = frame.copy() # Shows untouched RAW video
+        except:
+            display_frame = frame.copy()
 
-        # Brain / Severity Scanning
+        # Severity Scanning Model
         if not state.get("final_decision"):
             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]
+                    probs[:min(len(data), 4)] = data[:min(len(data), 4)]
                 elif res.boxes is not None and len(res.boxes) > 0:
                     for box in res.boxes:
                         cls_id = int(box.cls[0].item())
@@ -384,23 +360,20 @@ def video_stream_gen(stream_id, source, location):
                     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
+            except: pass
 
         _, buffer = cv2.imencode('.jpg', display_frame)
         last_buffer = buffer.tobytes()
         yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + last_buffer + b'\r\n')
         frame_count += 1
         
+        # Throttling if video loop runs faster than intended FPS
         if not is_live:
-            elapsed = time.time() - loop_start
-            sleep_time = (1.0 / fps) - elapsed
-            if sleep_time > 0:
-                time.sleep(sleep_time)
+            wait = (current_frame_idx / fps) - (time.time() - start_sync_time)
+            if wait > 0: time.sleep(wait)
     
     cap.release()
 
@@ -420,31 +393,22 @@ def predict_traffic_risk():
     try:
         if model_traffic is None: return jsonify({"error": "Tabular model missing"}), 500
         df = pd.DataFrame([{k: (v if v != "" else None) for k, v in data.items()}])
-        
         prob = float(model_traffic.predict_proba(df)[0][1] * 100)
-        
-        if prob >= 70: status = "Major"
-        elif prob >= 35: status = "Moderate"
-        else: status = "Minor"
-
+        status = "Major" if prob >= 70 else "Moderate" if prob >= 35 else "Minor"
         return jsonify({"status": status, "risk_probability_percentage": prob})
     except Exception as e: return jsonify({"error": str(e)}), 500
 
 @app.route('/favicon.ico')
-@app.route('/logo.PNG')
 @app.route('/logo.png')
+@app.route('/logo.PNG')
 def serve_logo():
-    """Forces browsers to read the logo with absolute pathing to fix Hugging Face 404s and Case Sensitivity."""
-    base_dir = os.path.dirname(os.path.abspath(__file__))
-    static_dir = os.path.join(base_dir, 'static')
-    
-    # Try exact uppercase first, fallback to lowercase if Linux changed it
-    if os.path.exists(os.path.join(static_dir, 'logo.PNG')):
-        return send_from_directory(static_dir, 'logo.PNG', mimetype='image/png')
-    elif os.path.exists(os.path.join(static_dir, 'logo.png')):
+    # Bypasses Hugging Face relative pathing issues directly resolving the static folder
+    static_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static')
+    if os.path.exists(os.path.join(static_dir, 'logo.png')):
         return send_from_directory(static_dir, 'logo.png', mimetype='image/png')
-    
-    return "Logo not found in static directory", 404
+    elif os.path.exists(os.path.join(static_dir, 'logo.PNG')):
+        return send_from_directory(static_dir, 'logo.PNG', mimetype='image/png')
+    return "Logo not found", 404
 
 @app.route('/')
 def index(): return render_template('index.html')