Update app.py

app.py

@@ -1,5 +1,14 @@
 import os
-import io
+# ==========================================
+# 🚨 ANTI-DEADLOCK CPU LIMITERS 🚨
+# Prevents PyTorch from freezing the Flask server on Windows CPUs
+os.environ["OMP_NUM_THREADS"] = "1"
+os.environ["OPENBLAS_NUM_THREADS"] = "1"
+os.environ["MKL_NUM_THREADS"] = "1"
+os.environ["VECLIB_MAXIMUM_THREADS"] = "1"
+os.environ["NUMEXPR_NUM_THREADS"] = "1"
+# ==========================================
+
 import cv2
 import base64
 import torch
@@ -18,44 +27,50 @@ from email.message import EmailMessage
 from flask import Flask, request, render_template, jsonify, Response, send_from_directory
 from werkzeug.utils import secure_filename
 
+# Force PyTorch to use 1 thread safely for both ops and interops
+torch.set_num_threads(1)
+try:
+    torch.set_num_interop_threads(1)
+except:
+    pass
+
 # --- Auto-install missing libraries ---
 try:
     from ultralytics import YOLO
     import easyocr
+    import yt_dlp
 except ModuleNotFoundError:
     import sys
     import subprocess
-    print("Installing libraries... This might take a minute...")
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "ultralytics", "scikit-learn==1.6.1", "easyocr", "pandas", "requests"])
+    print("Installing missing libraries... This might take a minute...", flush=True)
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "ultralytics", "scikit-learn==1.6.1", "easyocr", "pandas", "requests", "yt-dlp"])
     from ultralytics import YOLO
     import easyocr
+    import yt_dlp
 
 from torchvision.models.video import r3d_18
 
+print("--- BOOT SEQUENCE INITIATED ---", flush=True)
+
 app = Flask(__name__)
 
-# ==========================================
-# 🚨 ALERT CONFIGURATION (EMAIL SETUP) 🚨
-# ==========================================
 ALERT_EMAIL_SENDER = "gowreeshgowri50@gmail.com" 
 ALERT_EMAIL_PASSWORD = "omzw fjsu nwnr sgvl" 
 ALERT_EMAIL_RECEIVER = "ridhinmr32@gmail.com"
 ENABLE_EMAIL_ALERTS = True
 
-# --- Configurations ---
 UPLOAD_FOLDER = 'uploads'
 MODEL_FOLDER = 'models' 
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(MODEL_FOLDER, exist_ok=True)
 
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 classes = ['major', 'minor', 'moderate']
+active_streams = {}
 
-# --- Load Models ---
-print("Loading AI Models & ALPR... This might take a few seconds.")
 models_loaded = False
+print("Attempting to load AI Models & ALPR...", flush=True)
 try:
     yolo_path = os.path.join(MODEL_FOLDER, 'yolov8_accident_model.pt')
     model_yolo = YOLO(yolo_path)
@@ -70,21 +85,25 @@ try:
     svm_path = os.path.join(MODEL_FOLDER, 'ensemble_svm_model.pkl')
     model_svm = joblib.load(svm_path)
 
-    print("Loading OCR Engine...")
     ocr_reader = easyocr.Reader(['en'], gpu=torch.cuda.is_available())
-
     models_loaded = True
-    print("✅ Visual AI Models & OCR Loaded Successfully!")
+    print("✅ Visual AI Models & OCR Loaded Successfully!", flush=True)
+    
+    # 🚀 AI WARM-UP SEQUENCE 🚀
+    # We run a dummy frame through the models on boot so the server doesn't freeze when the user uploads a video!
+    print("Warming up Neural Networks in background...", flush=True)
+    dummy_img = np.zeros((640, 640, 3), dtype=np.uint8)
+    model_yolo(dummy_img, verbose=False)
+    print("✅ AI Warm-up complete. System ready for inference.", flush=True)
+
 except Exception as e:
-    print(f"⚠️ Warning: Could not load real visual models. Using mock simulation. Error: {e}")
+    print(f"⚠️ Warning: Could not load real visual models. Error: {e}", flush=True)
 
-# Load Traffic Predictor (Tabular Model)
 try:
     traffic_model_path = os.path.join(MODEL_FOLDER, 'traffic_predictor.pkl')
     model_traffic = joblib.load(traffic_model_path)
-    print("✅ Traffic Risk Predictor Loaded Successfully!")
+    print("✅ Traffic Risk Predictor Loaded Successfully!", flush=True)
 except Exception as e:
-    print(f"⚠️ Warning: Could not load traffic predictor model. Error: {e}")
     model_traffic = None
 
 def cleanup_old_files():
@@ -94,13 +113,14 @@ def cleanup_old_files():
             if os.path.isfile(file_path):
                 if time.time() - os.path.getmtime(file_path) > 3600:
                     os.remove(file_path)
-        except Exception as e: pass
+        except Exception: pass
 
 def get_camera_info_from_ip(url):
     try:
         parsed = urlparse(url)
         netloc = parsed.netloc.split(':')[0]
         if not netloc: return None, None
+        
         res = requests.get(f"http://ip-api.com/json/{netloc}", timeout=5).json()
         if res.get("status") == "success":
             city = res.get("city", "Unknown City")
@@ -111,214 +131,388 @@ def get_camera_info_from_ip(url):
             try:
                 wx_res = requests.get(f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true", timeout=5).json()
                 temp = wx_res["current_weather"]["temperature"]
-                cam_weather = f"{temp}°C, Active"
-            except Exception:
-                cam_weather = "--"
-            return cam_location, cam_weather
-    except Exception: pass
+                return cam_location, f"{temp}°C, Active"
+            except:
+                return cam_location, ""
+    except: pass
     return None, None
 
-def send_email_alert(location, confidence, plates_data, image_b64, severity, video_path=None):
-    if not ENABLE_EMAIL_ALERTS: return
+def process_accident_async(stream_id, frame, location, confidence, severity):
+    detected_plates = []
+    if models_loaded:
+        try:
+            ocr_results = ocr_reader.readtext(frame, detail=1)
+            for (bbox, text, prob) in ocr_results:
+                text_clean = text.upper().strip()
+                if len(text_clean) > 3 and any(c.isdigit() for c in text_clean):
+                    try:
+                        x_min = max(0, int(min([p[0] for p in bbox])))
+                        x_max = min(frame.shape[1], int(max([p[0] for p in bbox])))
+                        y_min = max(0, int(min([p[1] for p in bbox])))
+                        y_max = min(frame.shape[0], int(max([p[1] for p in bbox])))
+                        
+                        plate_crop = frame[y_min:y_max, x_min:x_max]
+                        if plate_crop.size > 0:
+                            _, buffer = cv2.imencode('.jpg', plate_crop)
+                            plate_b64 = base64.b64encode(buffer).decode('utf-8')
+                            detected_plates.append({"text": text_clean, "image": plate_b64})
+                    except Exception: pass
+        except Exception: pass
+
+    if stream_id in active_streams:
+        active_streams[stream_id]["plates"] = detected_plates
+    
+    if ENABLE_EMAIL_ALERTS:
+        try:
+            _, img_buffer = cv2.imencode('.jpg', frame)
+            img_b64 = base64.b64encode(img_buffer).decode('utf-8')
+            msg = EmailMessage()
+            msg['Subject'] = f"🚨 {severity.upper()} COLLISION DETECTED - {location}"
+            msg['From'] = ALERT_EMAIL_SENDER
+            msg['To'] = ALERT_EMAIL_RECEIVER
+            plates_text = ', '.join([p['text'] for p in detected_plates]) if detected_plates else 'None Detected'
+            msg.set_content(f"EMERGENCY DISPATCH ALERT\nLocation: {location}\nSeverity: {severity.upper()} COLLISION\nAI Confidence: {confidence}%\nDetected Plates: {plates_text}\nImmediate response requested.")
+            msg.add_attachment(base64.b64decode(img_b64), maintype='image', subtype='jpeg', filename='incident_snapshot.jpg')
+
+            context = ssl.create_default_context()
+            with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp:
+                smtp.login(ALERT_EMAIL_SENDER, ALERT_EMAIL_PASSWORD)
+                smtp.send_message(msg)
+        except Exception as e:
+            print(f"Email 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):
+    print(f"[AI THREAD] Started temporal analysis for {stream_id}", flush=True)
     try:
-        msg = EmailMessage()
-        msg['Subject'] = f"🚨 {severity.upper()} COLLISION DETECTED - {location}"
-        msg['From'] = ALERT_EMAIL_SENDER
-        msg['To'] = ALERT_EMAIL_RECEIVER
-        plates_text = ', '.join([p['text'] for p in plates_data]) if plates_data else 'None Detected'
-        content = f"EMERGENCY DISPATCH ALERT\nLocation: {location}\nSeverity: {severity.upper()}\nAI Confidence: {confidence}%\nDetected Plates: {plates_text}"
-        msg.set_content(content)
-        if image_b64:
-            msg.add_attachment(base64.b64decode(image_b64), maintype='image', subtype='jpeg', filename='incident.jpg')
-        context = ssl.create_default_context()
-        with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp:
-            smtp.login(ALERT_EMAIL_SENDER, ALERT_EMAIL_PASSWORD)
-            smtp.send_message(msg)
-    except Exception: pass
-
-def process_video_or_image(file_path):
-    is_image = file_path.lower().endswith(('.png', '.jpg', '.jpeg'))
-    frames_3d, yolo_probs = [], []
-    annotated_frame = best_raw_frame = None
-    if is_image:
-        frame = cv2.imread(file_path)
-        best_raw_frame = frame.copy()
-        res = model_yolo(file_path, verbose=False)[0]
-        annotated_frame = res.plot() 
-        if res.probs is not None: yolo_probs.append(res.probs.data.cpu().numpy())
-        elif res.boxes is not None and len(res.boxes) > 0:
-            confs = np.zeros(4)
-            for box in res.boxes:
-                cls_id, conf = int(box.cls[0].item()), box.conf[0].item()
-                if cls_id < 4 and conf > confs[cls_id]: confs[cls_id] = conf
-            yolo_probs.append(confs)
-        f_3d = cv2.resize(frame, (112, 112))
-        f_3d = cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB)
-        frames_3d = [f_3d] * 16
-    else:
-        cap = cv2.VideoCapture(file_path)
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        if frame_count <= 0: return None, None, None, None
-        intervals_3d = np.linspace(int(frame_count*0.7), max(0, frame_count-1), 16, dtype=int)
-        intervals_yolo = np.linspace(int(frame_count*0.75), max(0, frame_count-1), 5, dtype=int)
-        for idx in set(intervals_3d).union(set(intervals_yolo)):
-            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
-            ret, frame = cap.read()
-            if not ret: continue
-            if idx in intervals_3d:
-                f_3d = cv2.resize(frame, (112, 112))
-                f_3d = cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB)
-                frames_3d.append(f_3d)
-            if idx in intervals_yolo:
-                res = model_yolo(frame, verbose=False)[0]
-                best_raw_frame, annotated_frame = frame.copy(), res.plot() 
-                if res.probs is not None: yolo_probs.append(res.probs.data.cpu().numpy())
-                elif res.boxes is not None and len(res.boxes) > 0:
-                    confs = np.zeros(4)
-                    for box in res.boxes:
-                        cls_id, conf = int(box.cls[0].item()), box.conf[0].item()
-                        if cls_id < 4 and conf > confs[cls_id]: confs[cls_id] = conf
-                    yolo_probs.append(confs)
-        cap.release()
-    return frames_3d, yolo_probs, annotated_frame, best_raw_frame
-
-def get_real_prediction(file_path, location_data):
-    frames_3d, yolo_probs, annotated_frame, best_raw_frame = process_video_or_image(file_path)
-    if not frames_3d: return mock_predict(location_data, file_path)
-    if len(frames_3d) == 16:
-        tensor_3d = torch.tensor(np.array(frames_3d), dtype=torch.float32).permute(3, 0, 1, 2).unsqueeze(0).to(device) / 255.0
+        tensor_3d = torch.tensor(np.array(frames_3d_copy), dtype=torch.float32).permute(3, 0, 1, 2).unsqueeze(0).to(device) / 255.0
         with torch.no_grad():
             out_3d = model_3d(tensor_3d)
             prob_3d = torch.nn.functional.softmax(out_3d, dim=1).cpu().numpy()[0]
-    else: prob_3d = np.array([0.33, 0.33, 0.33])
-    if yolo_probs:
-        prob_mean, prob_max, prob_min = np.mean(yolo_probs, axis=0), np.max(yolo_probs, axis=0), np.min(yolo_probs, axis=0)
-        prob_mean, prob_max, prob_min = [np.pad(p[:4], (0, max(0, 4-len(p)))) if len(p) != 4 else p for p in [prob_mean, prob_max, prob_min]]
-    else: prob_mean = prob_max = prob_min = np.zeros(4)
-    combined_features = np.concatenate((prob_mean, prob_max, prob_min, prob_3d)).reshape(1, -1)
-    ensemble_probs = model_svm.predict_proba(combined_features)[0]
-    final_pred_idx = model_svm.predict(combined_features)[0]
-    severity_label, confidence = classes[final_pred_idx], ensemble_probs[final_pred_idx] * 100
-    yolo_max_conf = float(np.max(prob_max)) * 100
-    if confidence < 60 and yolo_max_conf > 60:
-        confidence = yolo_max_conf
-        severity_label = classes[min(int(np.argmax(prob_max)), 2)]
-    detected_plates = []
-    if best_raw_frame is not None:
-        ocr_results = ocr_reader.readtext(best_raw_frame, detail=1)
-        for (bbox, text, prob) in ocr_results:
-            text_clean = text.upper().strip()
-            if len(text_clean) > 4 and any(c.isalpha() for c in text_clean) and any(c.isdigit() for c in text_clean):
+            
+        combined_features = np.concatenate((prob_mean, prob_max, prob_min, prob_3d)).reshape(1, -1)
+        
+        is_acc = False
+        final_severity = "--"
+        final_conf = 0
+
+        try:
+            ensemble_probs = model_svm.predict_proba(combined_features)[0]
+            final_pred_idx = model_svm.predict(combined_features)[0]
+            
+            confidence = float(ensemble_probs[final_pred_idx] * 100)
+            severity_label = classes[final_pred_idx]
+            
+            if confidence > 85 and severity_label in classes:
+                is_acc = True
+                final_severity = severity_label
+                final_conf = confidence
+        except Exception as e:
+            print(f"[AI THREAD] SVM Error: {e}", flush=True)
+        
+        if not is_acc and yolo_max_conf > 85:
+            is_acc = True
+            final_severity = classes[min(int(np.argmax(prob_max)), 2)]
+            final_conf = yolo_max_conf
+
+        if yolo_max_conf < 15:
+            is_acc = False
+
+        state = active_streams.get(stream_id, {})
+        if state:
+            state["cnn"] = round(yolo_max_conf, 1)
+            state["rcnn"] = round(float(np.max(prob_3d)) * 100, 1)
+
+            if is_acc:
+                print(f"[AI THREAD] 🚨 ACCIDENT DETECTED! Confidence: {final_conf}%", flush=True)
+                state["is_accident"] = True
+                state["label"] = f"Accident Detected ({final_severity.capitalize()})"
+                state["severity"] = final_severity.capitalize()
+                state["confidence"] = round(float(final_conf), 1)
+                
+                if not state.get("alert_sent"):
+                    state["alert_sent"] = True
+                    threading.Thread(target=process_accident_async, args=(stream_id, raw_frame, location, final_conf, final_severity)).start()
+            else:
+                if not state.get("is_accident"): 
+                    state["is_accident"] = False
+                    state["label"] = "Monitoring Traffic" if yolo_max_conf >= 15 else "No Vehicles Detected"
+                    state["severity"] = "--"
+                    state["confidence"] = round(float(np.max(prob_mean)) * 100, 1) if yolo_max_conf >= 15 else 0.0
+
+        print(f"[AI THREAD] Finished temporal analysis.", flush=True)
+    except Exception as e:
+        print(f"[AI THREAD] CRASH in background thread: {e}", flush=True)
+    finally:
+        state = active_streams.get(stream_id, {})
+        if state:
+            state["is_analyzing"] = False
+
+def video_stream_gen(stream_id, source, location, raw_mode=False):
+    print(f"[STREAM] Booting up generator for stream: {stream_id}", flush=True)
+    
+    # 🚀 INSTANT CONNECTION FRAME 🚀
+    # Send a loading frame instantly so the web browser doesn't timeout while waiting for PyTorch!
+    load_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+    cv2.putText(load_frame, "Initializing AI Stream...", (100, 240), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 2)
+    _, buffer = cv2.imencode('.jpg', load_frame)
+    yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+    
+    is_image_file = isinstance(source, str) and source.lower().endswith(('.png', '.jpg', '.jpeg', '.webp'))
+    is_video_file = isinstance(source, str) and not is_image_file and not source.startswith('http')
+    
+    print(f"[STREAM] Mode: Image={is_image_file}, Video={is_video_file}, Source={source}", flush=True)
+    
+    static_frame = cv2.imread(source) if is_image_file else None
+    cap = cv2.VideoCapture(source) if not is_image_file else None
+    
+    if not is_image_file and (not cap or not cap.isOpened()):
+        print(f"[STREAM ERROR] Failed to open video source: {source}", flush=True)
+        if stream_id in active_streams: active_streams[stream_id]["label"] = "Stream Failed to Load"
+        err_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        cv2.putText(err_frame, "Stream Offline/Failed", (50, 240), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+        _, buffer = cv2.imencode('.jpg', err_frame)
+        yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+        return
+
+    frames_3d = []
+    yolo_probs = []
+    frame_count = 0
+    image_processed = False
+    last_annotated_frame = None
+
+    print("[STREAM] Entering while loop to yield frames...", flush=True)
+
+    while True:
+        start_time = time.time()
+
+        if is_image_file:
+            if static_frame is None: break
+            frame = static_frame.copy()
+            
+            # 🚀 CPU BURN OPTIMIZER 🚀
+            # If it's a photo, we only run the heavy AI ONCE! Then we just yield the saved image.
+            if image_processed and last_annotated_frame is not None:
+                time.sleep(0.5)
+                _, buffer = cv2.imencode('.jpg', last_annotated_frame)
+                yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+                continue
+        else:
+            ret, frame = cap.read()
+            if not ret: 
+                if frame_count == 0:
+                    print("[STREAM ERROR] Could not read the very first frame of the video!", flush=True)
+                    if stream_id in active_streams: active_streams[stream_id]["label"] = "Video Read Error"
+                    err_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+                    cv2.putText(err_frame, "Video Read Error", (50, 240), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+                    _, buffer = cv2.imencode('.jpg', err_frame)
+                    yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+                    break
+                elif is_video_file:
+                    print("[STREAM] Video naturally finished playing.", flush=True)
+                    if stream_id in active_streams:
+                        if not active_streams[stream_id].get("is_accident", False):
+                            active_streams[stream_id]["label"] = "No accident detected"
+                            active_streams[stream_id]["severity"] = "--"
+                            
+                    end_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+                    if active_streams.get(stream_id, {}).get("is_accident", False):
+                        cv2.putText(end_frame, "Finished - Collision Logged", (50, 240), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+                    else:
+                        cv2.putText(end_frame, "Finished - No Accident", (50, 240), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+                    
+                    _, buffer = cv2.imencode('.jpg', end_frame)
+                    yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+                    break 
+                else: 
+                    time.sleep(1)
+                    continue 
+            
+        raw_frame = frame.copy()
+        
+        if raw_mode:
+            annotated_frame = raw_frame
+        else:
+            if models_loaded:
                 try:
-                    x_min, x_max = max(0, int(min([p[0] for p in bbox]))), min(best_raw_frame.shape[1], int(max([p[0] for p in bbox])))
-                    y_min, y_max = max(0, int(min([p[1] for p in bbox]))), min(best_raw_frame.shape[0], int(max([p[1] for p in bbox])))
-                    _, buf = cv2.imencode('.jpg', best_raw_frame[y_min:y_max, x_min:x_max])
-                    detected_plates.append({"text": text_clean, "image": base64.b64encode(buf).decode('utf-8')})
-                except Exception: detected_plates.append({"text": text_clean, "image": ""})
-    encoded_img = ""
-    if annotated_frame is not None:
-        _, buffer = cv2.imencode('.jpg', annotated_frame)
-        encoded_img = base64.b64encode(buffer).decode('utf-8')
-    if confidence > 68:
-        threading.Thread(target=send_email_alert, args=(location_data, confidence, detected_plates, encoded_img, severity_label, file_path)).start()
-        lbl = f"Accident Detected ({severity_label.capitalize()})"
-    else:
-        lbl = "Normal Traffic"
-        severity_label = "--"
-    return {"label": lbl, "severity": severity_label.capitalize(), "confidence": round(float(confidence), 1), "cnn": round(float(np.max(prob_max)) * 100, 1), "rcnn": round(float(np.max(prob_3d)) * 100, 1), "alert_sent": confidence > 68, "plates": detected_plates, "image": encoded_img}
-
-def mock_predict(location_data, file_path=None):
-    svm_p, cnn_p, rcnn_p = np.random.uniform(0.7, 0.95), np.random.uniform(0.6, 0.95), np.random.uniform(0.6, 0.9)
-    ensemble_p = (svm_p + cnn_p + rcnn_p) / 3
-    sev = np.random.choice(["Major", "Moderate", "Minor"])
-    threading.Thread(target=send_email_alert, args=(location_data, round(float(ensemble_p)*100, 1), [], None, sev, file_path)).start()
-    return {"label": f"Accident Detected ({sev})", "severity": sev, "confidence": round(float(ensemble_p)*100, 1), "cnn": round(cnn_p*100, 1), "rcnn": round(rcnn_p*100, 1), "alert_sent": True, "plates": [], "image": ""}
+                    res = model_yolo(frame, conf=0.25, verbose=False)[0]
+                    annotated_frame = res.plot(labels=True, conf=True)
+
+                    if res.probs is not None:
+                        yolo_probs.append(res.probs.data.cpu().numpy())
+                    elif res.boxes is not None and len(res.boxes) > 0:
+                        confs = np.zeros(4)
+                        for box in res.boxes:
+                            cls_id = int(box.cls[0].item())
+                            conf = box.conf[0].item()
+                            if cls_id < 4 and conf > confs[cls_id]: 
+                                confs[cls_id] = conf
+                        yolo_probs.append(confs)
+                    else:
+                        yolo_probs.append(np.zeros(4))
+
+                    if len(yolo_probs) > 10: yolo_probs.pop(0)
+                except Exception as e:
+                    print(f"[STREAM ERROR] YOLO Inference crashed: {e}", flush=True)
+                    annotated_frame = frame
+                    yolo_probs.append(np.zeros(4))
+            else:
+                annotated_frame = frame
+
+            f_3d = cv2.resize(frame, (112, 112))
+            f_3d = cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB)
+            frames_3d.append(f_3d)
+            if len(frames_3d) > 16: frames_3d.pop(0)
+
+            if len(frames_3d) < 16:
+                frames_3d = [f_3d] * 16
+
+            if not models_loaded:
+                if stream_id in active_streams:
+                    active_streams[stream_id]["label"] = "Models Missing"
+            elif len(frames_3d) == 16 and (frame_count % 8 == 0 or is_image_file or frame_count == 0):
+                
+                state = active_streams.get(stream_id, {})
+                if state and not state.get("is_analyzing", False):
+                    if frame_count % 30 == 0:
+                        print(f"[STREAM] Dispatching AI Thread for frame {frame_count}", flush=True)
+                    state["is_analyzing"] = True
+                    
+                    prob_mean = np.mean(yolo_probs, axis=0) if len(yolo_probs) > 0 else np.zeros(4)
+                    prob_max = np.max(yolo_probs, axis=0) if len(yolo_probs) > 0 else np.zeros(4)
+                    prob_min = np.min(yolo_probs, axis=0) if len(yolo_probs) > 0 else np.zeros(4)
+                    
+                    if len(prob_mean) < 4:
+                        prob_mean = np.pad(prob_mean, (0, 4 - len(prob_mean)))
+                        prob_max = np.pad(prob_max, (0, 4 - len(prob_max)))
+                        prob_min = np.pad(prob_min, (0, 4 - len(prob_min)))
+                    elif len(prob_mean) > 4:
+                        prob_mean, prob_max, prob_min = prob_mean[:4], prob_max[:4], prob_min[:4]
+
+                    yolo_max_conf = float(np.max(prob_max)) * 100
+
+                    frames_copy = [np.copy(f) for f in frames_3d]
+                    threading.Thread(
+                        target=run_temporal_analysis, 
+                        args=(stream_id, frames_copy, prob_max, prob_mean, prob_min, yolo_max_conf, raw_frame.copy(), location)
+                    ).start()
+
+        last_annotated_frame = annotated_frame
+        image_processed = True
+
+        try:
+            _, buffer = cv2.imencode('.jpg', annotated_frame)
+            yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+            if frame_count == 0:
+                print("[STREAM] ✅ First frame successfully yielded to web browser!", flush=True)
+        except Exception as e:
+            print(f"[STREAM ERROR] Failed to encode and yield frame to browser: {e}", flush=True)
+        
+        frame_count += 1
+        
+        elapsed = time.time() - start_time
+        if is_video_file and elapsed < 0.033:
+            time.sleep(0.033 - elapsed)
+
+    if cap: cap.release()
+    print(f"[STREAM] Generator closed for {stream_id}", flush=True)
 
 @app.route('/')
-def index(): return render_template('index.html')
+def index():
+    return render_template('index.html')
 
-@app.route('/upload_media', methods=['POST'])
-def upload_media():
+@app.route('/init_upload', methods=['POST'])
+def init_upload():
+    cleanup_old_files()
     if 'file' not in request.files: return jsonify({"error": "No file"}), 400
     file = request.files['file']
     unique_id = f"{uuid.uuid4().hex}_{secure_filename(file.filename)}"
-    file.save(os.path.join(app.config['UPLOAD_FOLDER'], unique_id))
-    return jsonify({"video_id": unique_id})
-
-@app.route('/analyze_media', methods=['POST'])
-def analyze_media():
-    unique_id = request.json.get('video_id')
-    file_path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(unique_id))
-    if not os.path.exists(file_path): return jsonify({"error": "File not found"}), 404
-    try:
-        results = get_real_prediction(file_path, "Uploaded Media") if models_loaded else mock_predict("Uploaded Media", file_path)
-        results.update({"video_id": unique_id, "is_video": True})
-        return jsonify(results)
-    except Exception as e: return jsonify({"error": str(e)}), 500
+    file_path = os.path.join(app.config['UPLOAD_FOLDER'], unique_id)
+    file.save(file_path)
+    
+    print(f"[HTTP] Received Upload: {unique_id}", flush=True)
+    active_streams[unique_id] = {"label": "Analyzing...", "confidence": 0, "cnn": 0, "rcnn": 0, "severity": "--", "plates": [], "alert_sent": False, "is_accident": False, "is_analyzing": False}
+    return jsonify({"stream_id": unique_id, "location": "Nil", "weather": "Nil", "time": "Nil"})
+
+@app.route('/init_stream', methods=['POST'])
+def init_stream():
+    cleanup_old_files()
+    stream_url = request.json.get('url', '').replace('&amp;', '&')
+    location = request.json.get('location', 'Unknown IP')
+    
+    print(f"[HTTP] Connecting to Live IP: {stream_url}", flush=True)
+    if 'youtube.com' in stream_url or 'youtu.be' in stream_url:
+        try:
+            ydl_opts = {'format': 'best', 'quiet': True}
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(stream_url, download=False)
+                stream_url = info.get('url', stream_url)
+        except Exception as e:
+            print(f"Failed to extract YouTube link: {e}", flush=True)
 
-@app.route('/predict_stream', methods=['POST'])
-def predict_stream():
-    data = request.json
-    stream_url, loc = data.get('url', '').replace('&amp;', '&'), data.get('location', 'Unknown')
     cam_loc, cam_wx = get_camera_info_from_ip(stream_url)
-    if cam_loc: loc = cam_loc
-    cap = cv2.VideoCapture(stream_url)
-    frames = []
-    for _ in range(90):
-        ret, frame = cap.read()
-        if not ret: break
-        frames.append(frame)
-    cap.release()
-    if not frames: return jsonify({"error": "Stream unreachable"}), 400
-    uid = f"stream_{uuid.uuid4().hex}.webm"
-    path = os.path.join(app.config['UPLOAD_FOLDER'], uid)
-    h, w, _ = frames[0].shape
-    out = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*'VP80'), 30.0, (w, h))
-    for f in frames: out.write(f)
-    out.release()
-    results = get_real_prediction(path, loc) if models_loaded else mock_predict(loc, path)
-    if cam_loc: results.update({"cam_location": cam_loc, "cam_weather": cam_wx})
-    results.update({"video_id": uid, "is_video": True, "source_type": 'live'})
-    return jsonify(results)
+    if cam_loc: location = cam_loc
+    
+    stream_id = f"live_{uuid.uuid4().hex}"
+    app.config[f'SRC_{stream_id}'] = stream_url
+    
+    active_streams[stream_id] = {"label": "Analyzing...", "confidence": 0, "cnn": 0, "rcnn": 0, "severity": "--", "plates": [], "alert_sent": False, "is_accident": False, "is_analyzing": False}
+    return jsonify({"stream_id": stream_id, "location": location, "weather": cam_wx or "--", "time": time.strftime("%H:%M:%S")})
+
+@app.route('/video_feed/<stream_id>')
+def video_feed(stream_id):
+    print(f"\n>>> BROWSER REQUESTED STREAM: {stream_id}", flush=True)
+    source = app.config.get(f'SRC_{stream_id}')
+    if not source: source = os.path.join(app.config['UPLOAD_FOLDER'], stream_id)
+    location = request.args.get('loc', 'Unknown Location')
+    return Response(video_stream_gen(stream_id, source, location, raw_mode=False), mimetype='multipart/x-mixed-replace; boundary=frame')
+
+@app.route('/raw_feed/<stream_id>')
+def raw_feed(stream_id):
+    source = app.config.get(f'SRC_{stream_id}')
+    if not source: return "Not a live stream", 400
+    return Response(video_stream_gen(stream_id, source, "Unknown", raw_mode=True), mimetype='multipart/x-mixed-replace; boundary=frame')
+
+@app.route('/stream_status/<stream_id>')
+def stream_status(stream_id):
+    return jsonify(active_streams.get(stream_id, {}))
+
+@app.route('/video/<video_id>')
+def get_video(video_id):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], secure_filename(video_id))
 
 @app.route('/predict_traffic_risk', methods=['POST'])
 def predict_traffic_risk():
     data = request.json
     try:
-        if not model_traffic:
-            p = np.random.uniform(10, 85)
-            return jsonify({"risk_probability_percentage": round(p, 1), "will_accident_happen": p > 50, "status": "High Risk" if p > 50 else "Low Risk"})
-        df = pd.DataFrame([{k: (v if v != "" else None) for k, v in data.items()}])
+        if model_traffic is None: return jsonify({"error": "Tabular model not loaded"}), 500
+        cleaned_data = {k: (v if v != "" else None) for k, v in data.items()}
+        df = pd.DataFrame([cleaned_data])
+        
         for col in ['Traffic_Density', 'Speed_Limit', 'Number_of_Vehicles', 'Driver_Alcohol', 'Driver_Age', 'Driver_Experience']:
             if col in df.columns: df[col] = pd.to_numeric(df[col], errors='coerce')
-        if 'Speed_Limit' in df.columns and 'Driver_Alcohol' in df.columns: df['Speed_Alcohol_Risk'] = (df['Speed_Limit'] // 10) * (df['Driver_Alcohol'] + 0.1)
-        if 'Traffic_Density' in df.columns and 'Number_of_Vehicles' in df.columns: df['Congestion_Risk'] = df['Traffic_Density'] * df['Number_of_Vehicles']
+        if 'Speed_Limit' in df.columns and 'Driver_Alcohol' in df.columns: 
+            df['Speed_Alcohol_Risk'] = (df['Speed_Limit'] // 10) * (df['Driver_Alcohol'] + 0.1)
+        if 'Traffic_Density' in df.columns and 'Number_of_Vehicles' in df.columns: 
+            df['Congestion_Risk'] = df['Traffic_Density'] * df['Number_of_Vehicles']
+        
+        prediction = model_traffic.predict(df)[0]
         prob = model_traffic.predict_proba(df)[0][1] * 100
-        return jsonify({"risk_probability_percentage": round(prob, 1), "will_accident_happen": prob >= 50, "status": "High Risk" if prob >= 50 else "Low Risk"})
-    except Exception as e: return jsonify({"error": str(e)}), 500
-
-@app.route('/video/<video_id>')
-def get_video(video_id): return send_from_directory(app.config['UPLOAD_FOLDER'], secure_filename(video_id))
-
-@app.route('/stream_tracking/<video_id>')
-def stream_tracking(video_id):
-    path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(video_id))
-    def generate():
-        cap = cv2.VideoCapture(path)
-        fps = cap.get(cv2.CAP_PROP_FPS) or 30
-        delay = 1.0 / fps
-        while cap.isOpened():
-            start = time.time()
-            ret, frame = cap.read()
-            if not ret: cap.set(cv2.CAP_PROP_POS_FRAMES, 0); continue
-            if models_loaded: frame = model_yolo(frame, conf=0.15, verbose=False)[0].plot()
-            _, buf = cv2.imencode('.jpg', frame)
-            yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buf.tobytes() + b'\r\n')
-            elapsed = time.time() - start
-            if elapsed < delay: time.sleep(delay - elapsed)
-        cap.release()
-    return Response(generate(), mimetype='multipart/x-mixed-replace; boundary=frame')
+        
+        # 🚨 100% SAFE JSON SERIALIZATION 🚨
+        # Extracts raw int/float mathematically to guarantee no Numpy bool_ errors on mobile
+        prediction_val = int(prediction.item()) if hasattr(prediction, 'item') else int(prediction)
+        native_prediction = True if prediction_val > 0 else False
+        native_prob = float(prob.item()) if hasattr(prob, 'item') else float(prob)
+        
+        return jsonify({
+            "risk_probability_percentage": round(native_prob, 1), 
+            "will_accident_happen": native_prediction, 
+            "status": "High Risk Detected" if native_prob >= 50 else "Low Risk Environment"
+        })
+    except Exception as e: 
+        print(f"[PREDICTOR ERROR] {str(e)}", flush=True)
+        return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':
-    # Mandatory for Hugging Face Spaces Docker environments
-    app.run(host='0.0.0.0', port=7860)
+    # Threaded=True prevents single-thread blocking
+    app.run(host='0.0.0.0', port=7860, threaded=True)