Update app.py

app.py

@@ -1,1001 +1,293 @@
-# import os
-# import cv2
-# import torch
-# import numpy as np
-# import time
-# from datetime import datetime
-# import threading
-# import base64
-# from werkzeug.utils import secure_filename
-
-# # --- Load .env file ---
-# from dotenv import load_dotenv
-# load_dotenv() # Reads the .env file and sets environment variables
-# # --- END ---
-
-# from flask import Flask, render_template, Response, request, jsonify
-# from flask_socketio import SocketIO
-
-# # Important: Make sure your custom utility scripts are accessible
-# from utils.load_model import load_models
-# from utils.utils import build_transforms
-# from network.TorchUtils import get_torch_device
-# from yolo_detection import analyze_video_with_yolo
-# from video_sumrrizer import summarize_video  # Your summarizer
-
-# # ---- App Setup ----
-# app = Flask(__name__)
-# app.config['SECRET_KEY'] = 'your_secret_key!'
-# UPLOAD_FOLDER = 'uploads'
-# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-# socketio = SocketIO(app, async_mode='eventlet')
-
-# # ---- Global Config & Model Loading ----
-# print("[INFO] Loading models...")
-# DEVICE = get_torch_device()
-# FEATURE_EXTRACTOR_PATH = "pretrained/c3d.pickle"
-# AD_MODEL_PATH = "exps/c3d/models/epoch_80000.pt"
-# YOLO_MODEL_PATH = "yolo_my_model.pt"
-# SAVE_DIR = "outputs/anomaly_frames"
-# ANOMALY_THRESHOLD = 0.4 # Using 0.4 from pipeline_demo
-# COOLDOWN_SECS = 60.0 # 60 seconds cooldown
-# os.makedirs(SAVE_DIR, exist_ok=True)
-
-# # --- Get the API key safely ---
-# OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-# if not OPENAI_API_KEY:
-#     print("⚠️ WARNING: OPENAI_API_KEY environment variable not set OR not found in .env file. Summarizer will fail.")
-
-# anomaly_detector, feature_extractor = load_models(
-#     FEATURE_EXTRACTOR_PATH, AD_MODEL_PATH, features_method="c3d", device=DEVICE
-# )
-# feature_extractor.eval()
-# anomaly_detector.eval()
-# TRANSFORMS = build_transforms(mode="c3d")
-# print("[INFO] Models loaded successfully.")
-
-# VIDEO_PATHS = {
-#     "Abuse": "static/videos/Abuse.mp4",
-#     "Arrest": "static/videos/Arrest.mp4",
-#     "Arson": "static/videos/Arson.mp4",
-#     "Assault": "static/videos/Assault.mp4",
-#     "Burglary": "static/videos/Burglary.mp4",
-#     "Explosion": "static/videos/Explosion.mp4",
-#     "Fighting": "static/videos/Fighting.mp4",
-#     "RoadAccidents": "static/videos/RoadAccidents.mp4",
-#     "Robbery": "static/videos/Robbery.mp4",
-#     "Shooting": "static/videos/Shooting.mp4",
-#     "Shoplifting": "static/videos/Shoplifting.mp4",
-#     "Stealing": "static/videos/Stealing.mp4",
-#     "Vandalism": "static/videos/Vandalism.mp4",
-#     "Normal": "static/videos/Normal.mp4"
-# }
-
-# # --- Threading control ---
-# thread = None
-# thread_lock = threading.Lock()
-# stop_event = threading.Event()
-
-# def smooth_score(scores, new_score, window=5):
-#     scores.append(new_score)
-#     if len(scores) > window:
-#         scores.pop(0)
-#     return float(np.mean(scores))
-
-# # --- Background task for saving and summarizing ---
-# def _save_clip_and_summarize(video_path, clip_dir, initial_frames, fps, width, height):
-#     """
-#     Saves a 30s clip and runs the summarizer ON THAT SAVED CLIP.
-#     This runs in a separate thread.
-#     Emits recording=False when finished.
-#     """
-#     summary_text = None
-#     out_path = os.path.join(clip_dir, "anomaly_clip.mp4")
-
-#     try:
-#         # 1. Save the 30-second clip
-#         socketio.emit('update_status', {'status': 'Saving 30s clip...'})
-#         cap2 = cv2.VideoCapture(video_path)
-#         if not cap2.isOpened():
-#             raise Exception(f"Save thread: Cannot open video {video_path}")
-
-#         fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-#         out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
-
-#         for f in initial_frames:
-#             out.write(f)
-#             # socketio.sleep(0) # Optional: uncomment if main thread still unresponsive
-
-#         frames_to_save = int(fps * 30)
-#         remaining_frames_to_save = frames_to_save - len(initial_frames)
-
-#         # Assuming seek works, otherwise read from start (less accurate for live)
-#         # Attempt seek if possible, otherwise just continue reading
-#         # start_frame_approx = int(cap2.get(cv2.CAP_PROP_POS_FRAMES)) - len(initial_frames) # This might not be right
-#         # cap2.set(cv2.CAP_PROP_POS_FRAMES, start_frame_approx) # Attempt seek
-
-#         for _ in range(remaining_frames_to_save):
-#             ret, frame = cap2.read()
-#             if not ret: break
-#             out.write(frame)
-#             # socketio.sleep(0) # Optional: uncomment if main thread still unresponsive
-
-#         out.release()
-#         cap2.release()
-#         print(f"✅ [INFO] Saved 30-sec anomaly clip -> {out_path}")
-
-#         # 2. Summarize THE SAVED CLIP
-#         socketio.emit('update_status', {'status': 'Running video summarizer on the clip...'})
-
-#         api_key_from_env = os.getenv("OPENAI_API_KEY") # Get key again in thread
-#         if not api_key_from_env:
-#              raise ValueError("OPENAI_API_KEY missing in background thread.")
-
-#         summary_text = summarize_video(video_path=out_path, api=api_key_from_env)
-#         print("\n✅ VIDEO SUMMARY:\n", summary_text, "\n")
-
-#     except Exception as e:
-#         summary_text = f"Summarizer Error: {e}"
-#         print(f"❌ [ERROR] _save_clip_and_summarize failed: {e}")
-#     finally:
-#         # Ensure a message is always sent back
-#         if summary_text is None:
-#             summary_text = "Summarizer Error: Unknown failure in background thread."
-
-#         # Send the final summary (or error) to the UI
-#         socketio.emit('update_summary', {'summary': summary_text})
-#         # Tell the UI the recording has finished
-#         socketio.emit('recording_signal', {'recording': False})
-#         print("ℹ️ Background processing finished.")
-
-
-# # --- Main video processing loop (Corrected) ---
-# def video_processing_task(video_path):
-#     global thread
-#     try:
-#         cap = cv2.VideoCapture(video_path)
-#         if not cap.isOpened():
-#             socketio.emit('processing_error', {'error': 'Could not open video file.'})
-#             return
-
-#         frame_buffer = []
-#         last_save_time = 0.0 # Initialize with float
-#         recent_scores = []
-
-#         # --- ADJUSTED: Frame skipping for graph speed ---
-#         FRAME_SKIP = 4 # Process 1 frame, skip next 4. Increase if needed.
-#         # --- END ---
-
-#         frame_count = 0
-
-#         fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
-#         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-#         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-#         while cap.isOpened() and not stop_event.is_set():
-#             socketio.sleep(0.001) # Small sleep to prevent 100% CPU, allow task switching
-#             ret, frame = cap.read()
-#             if not ret: break
-
-#             frame_count += 1
-#             # --- APPLY FRAME SKIPPING ---
-#             if frame_count % (FRAME_SKIP + 1) != 0:
-#                  continue
-#             # --- END ---
-
-#             frame_buffer.append(frame.copy())
-
-#             if len(frame_buffer) == 16:
-#                 # Anomaly Detection
-#                 frames_resized = [cv2.resize(f, (112, 112)) for f in frame_buffer]
-#                 clip_np = np.array(frames_resized, dtype=np.uint8)
-#                 clip_torch = torch.from_numpy(clip_np)
-#                 clip_torch = TRANSFORMS(clip_torch)
-#                 clip_torch = clip_torch.unsqueeze(0).to(DEVICE)
-
-#                 with torch.no_grad():
-#                     features = feature_extractor(clip_torch).detach()
-#                     score_tensor = anomaly_detector(features).detach()
-#                     score = float(score_tensor.view(-1)[0].item())
-
-#                 score = smooth_score(recent_scores, score)
-#                 score = float(np.clip(score, 0, 1))
-#                 socketio.emit('update_graph', {'score': score}) # Send score regardless of anomaly
-
-#                 # Anomaly Actions (Check threshold and cooldown)
-#                 now = time.time()
-#                 if score > ANOMALY_THRESHOLD and (now - last_save_time) >= COOLDOWN_SECS:
-#                     print(f"🔥 Anomaly detected! Score: {score:.2f}, Cooldown passed.")
-#                     last_save_time = now # Update time *immediately*
-
-#                     # Emit recording signal ONLY when anomaly confirmed + cooldown passed
-#                     socketio.emit('recording_signal', {'recording': True})
-
-#                     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-#                     clip_dir = os.path.join(SAVE_DIR, f"anomaly_{timestamp}")
-#                     os.makedirs(clip_dir, exist_ok=True)
-
-#                     # Run YOLO immediately on the latest frame
-#                     yolo_frame_path = os.path.join(clip_dir, "yolo_frame.jpg")
-#                     preview_frame_img = frame_buffer[-1].copy()
-#                     cv2.imwrite(yolo_frame_path, preview_frame_img)
-
-#                     try:
-#                         yolo_result = analyze_video_with_yolo(yolo_frame_path, model_path=YOLO_MODEL_PATH, return_class=True)
-#                         yolo_text = f"🚨 Anomaly Detected → YOLO: {yolo_result}"
-#                     except Exception as e:
-#                         yolo_text = f"YOLO Error: {e}"
-
-#                     # Send YOLO results immediately
-#                     socketio.emit('update_yolo_text', {'text': yolo_text})
-#                     _, buffer = cv2.imencode('.jpg', preview_frame_img)
-#                     b64_str = base64.b64encode(buffer).decode('utf-8')
-#                     socketio.emit('update_yolo_image', {'image_data': b64_str})
-
-#                     # Signal loading for summary
-#                     socketio.emit('update_summary', {'summary': 'loading'})
-
-#                     # Start background task for saving & summarizing
-#                     socketio.start_background_task(
-#                         _save_clip_and_summarize,
-#                         video_path,
-#                         clip_dir,
-#                         frame_buffer.copy(), # Pass copy of current buffer
-#                         fps,
-#                         width,
-#                         height
-#                     )
-#                 # End of anomaly action block
-
-#                 frame_buffer.clear() # Clear buffer after processing or anomaly trigger
-
-#         cap.release()
-#         if not stop_event.is_set():
-#             socketio.emit('processing_finished', {'message': 'Video finished.'})
-#             print("🏁 Video processing finished normally.")
-
-#     except Exception as e:
-#          print(f"❌ [ERROR] Unhandled exception in video_processing_task: {e}")
-#          socketio.emit('processing_error', {'error': f'Runtime error: {e}'})
-#     finally:
-#         # Cleanup: Ensure the global thread variable is reset
-#         with thread_lock:
-#             # Check if this *specific* thread instance is the one finishing
-#             # This check helps prevent race conditions if reset is called rapidly
-#             # if threading.current_thread() is thread: # This comparison might not work with eventlet's green threads
-#             if thread is not None: # Simpler check: if a thread exists, clear it
-#                  print("🧹 Cleaning up video processing task.")
-#                  thread = None
-#                  stop_event.clear()
-
-
-# # --- (Routes: /, /upload, /video_stream remain the same) ---
-# @app.route('/')
-# def index():
-#     # Pass the list of demo video names to the template
-#     return render_template('index.html', anomaly_names=VIDEO_PATHS.keys())
-
-# @app.route('/upload', methods=['POST'])
-# def upload_file():
-#     if 'video' not in request.files:
-#         return jsonify({'error': 'No video file found'}), 400
-#     file = request.files['video']
-#     if file.filename == '':
-#         return jsonify({'error': 'No video file selected'}), 400
-#     if file:
-#         filename = secure_filename(file.filename)
-#         # Add timestamp for uniqueness
-#         unique_filename = f"{datetime.now().strftime('%Y%m%d%H%M%S')}_{filename}"
-#         save_path = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
-#         try:
-#             file.save(save_path)
-#             print(f"✅ [INFO] File uploaded successfully: {save_path}")
-#             return jsonify({'success': True, 'filename': unique_filename})
-#         except Exception as e:
-#             print(f"❌ [ERROR] File save failed: {e}")
-#             return jsonify({'error': f'File save failed: {e}'}), 500
-#     # Fallback error
-#     return jsonify({'error': 'Unknown file upload error'}), 500
-
-
-# @app.route('/video_stream/<source>/<path:filename>') # Use path converter for flexibility
-# def video_stream(source, filename):
-#     path = None
-#     safe_filename = secure_filename(filename) # Sanitize filename
-
-#     if source == 'demo':
-#         # Demo keys should ideally be safe, direct lookup might be fine
-#         path = VIDEO_PATHS.get(filename)
-#     elif source == 'upload':
-#         path = os.path.join(app.config['UPLOAD_FOLDER'], safe_filename)
-#     else:
-#         print(f"⚠️ [WARN] Invalid source requested for video stream: {source}")
-#         return "Invalid source", 404
-
-#     if not path or not os.path.exists(path):
-#         print(f"❌ [ERROR] Video stream file not found: {path}")
-#         return "Video not found", 404
-
-#     def generate():
-#         try:
-#             with open(path, "rb") as f:
-#                 while chunk := f.read(1024 * 1024): # Stream in 1MB chunks
-#                     yield chunk
-#                     socketio.sleep(0.0001) # Small sleep during streaming helps prevent blocking
-#         except Exception as e:
-#             print(f"❌ [ERROR] Error during video streaming generation for {path}: {e}")
-
-#     # Use Werkzeug's FileWrapper for potentially better streaming performance/handling
-#     # from werkzeug.wsgi import FileWrapper
-#     # response = Response(FileWrapper(open(path, "rb")), mimetype="video/mp4", direct_passthrough=True)
-#     # return response
-#     print(f"ℹ️ Streaming video: {path}")
-#     return Response(generate(), mimetype="video/mp4")
-
-
-# # --- (SocketIO handlers: start_processing, reset_system remain the same) ---
-# @socketio.on('start_processing')
-# def handle_start_processing(data):
-#     global thread
-#     with thread_lock:
-#         if thread is None: # Only start if no thread is running
-#             stop_event.clear() # Ensure stop event is clear before starting
-#             source = data.get('source')
-#             filename = data.get('filename')
-#             video_path = None
-#             safe_filename = secure_filename(filename) if filename else None
-
-#             if not safe_filename:
-#                  print("❌ [ERROR] Start processing requested with invalid filename.")
-#                  socketio.emit('processing_error', {'error': 'Invalid filename provided.'})
-#                  return
-
-#             if source == 'demo':
-#                 video_path = VIDEO_PATHS.get(filename) # Use original filename for dict lookup
-#             elif source == 'upload':
-#                 video_path = os.path.join(app.config['UPLOAD_FOLDER'], safe_filename)
-
-#             if video_path and os.path.exists(video_path):
-#                 print(f"🚀 [INFO] Starting processing for '{safe_filename}' from source '{source}'")
-#                 # Start the background task using socketio's method for compatibility with eventlet/gevent
-#                 thread = socketio.start_background_task(target=video_processing_task, video_path=video_path)
-#             else:
-#                  error_msg = f'Video file not found at path: {video_path}'
-#                  print(f"❌ [ERROR] {error_msg}")
-#                  socketio.emit('processing_error', {'error': 'Video file could not be found.'}) # User-friendly message
-#         else:
-#              # Prevent starting multiple threads
-#              print("⚠️ [WARN] Processing task already running. Ignoring new 'start_processing' request.")
-#              socketio.emit('update_status', {'status': 'Processing is already in progress.'})
-
-
-# @socketio.on('reset_system')
-# def handle_reset():
-#     global thread
-#     with thread_lock:
-#         if thread is not None:
-#             print("🔄 [INFO] Reset requested. Signaling background task to stop...")
-#             stop_event.set()
-#             # The background task's 'finally' block handles cleanup (thread = None, stop_event.clear())
-#         else:
-#             print("ℹ️ [INFO] Reset requested, but no processing task was running.")
-#     # Always confirm reset to UI immediately
-#     socketio.emit('system_reset_confirm')
-#     print("✅ [INFO] Reset confirmation sent to client.")
-
-
-# if __name__ == '__main__':
-#     print("🐍 [INFO] Starting Flask server...")
-#     # Use host='0.0.0.0' to allow access from other devices on your network
-#     # Use debug=True for development (auto-reloads), False for production
-#     # Port 5000 is the default for Flask
-#     socketio.run(app, debug=True)
-
-#============================================================================================================================================================================
-
-
-# import os
-# import cv2
-# import torch
-# import numpy as np
-# import time
-# from datetime import datetime
-# import threading
-# import base64
-# from werkzeug.utils import secure_filename
-
-# # --- Load .env file ---
-# from dotenv import load_dotenv
-# load_dotenv()
-# # --- END ---
-
-# from flask import Flask, render_template, Response, request, jsonify
-# from flask_socketio import SocketIO
-
-# # Important: Adjust imports if your structure changed
-# from utils.load_model import load_models
-# from utils.utils import build_transforms
-# from network.TorchUtils import get_torch_device
-# from yolo_detection import analyze_video_with_yolo
-# from video_sumrrizer import summarize_video # Your summarizer
-
-# # ---- App Setup ----
-# app = Flask(__name__)
-# app.config['SECRET_KEY'] = 'your_secret_key!'
-# UPLOAD_FOLDER = 'uploads'
-# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-# socketio = SocketIO(app, async_mode='eventlet')
-
-# # ---- Global Config & Model Loading ----
-# print("[INFO] Loading models...")
-# DEVICE = get_torch_device()
-# FEATURE_EXTRACTOR_PATH = "pretrained/c3d.pickle"
-# AD_MODEL_PATH = "exps/c3d/models/epoch_80000.pt"
-# YOLO_MODEL_PATH = "yolo_my_model.pt"
-# SAVE_DIR = "outputs/anomaly_frames"
-# ANOMALY_THRESHOLD = 0.4
-# COOLDOWN_SECS = 60.0
-# os.makedirs(SAVE_DIR, exist_ok=True)
-
-# OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-# if not OPENAI_API_KEY:
-#     print("⚠️ WARNING: OPENAI_API_KEY not set!")
-
-# anomaly_detector, feature_extractor = load_models(
-#     FEATURE_EXTRACTOR_PATH, AD_MODEL_PATH, features_method="c3d", device=DEVICE
-# )
-# feature_extractor.eval()
-# anomaly_detector.eval()
-# TRANSFORMS = build_transforms(mode="c3d")
-# print("[INFO] Models loaded successfully.")
-
-# VIDEO_PATHS = { # Ensure these paths are correct relative to app.py
-#     "Abuse": "static/videos/Abuse.mp4", "Arrest": "static/videos/Arrest.mp4",
-#     "Arson": "static/videos/Arson.mp4", "Assault": "static/videos/Assault.mp4",
-#     "Burglary": "static/videos/Burglary.mp4", "Explosion": "static/videos/Explosion.mp4",
-#     "Fighting": "static/videos/Fighting.mp4", "RoadAccidents": "static/videos/RoadAccidents.mp4",
-#     "Robbery": "static/videos/Robbery.mp4", "Shooting": "static/videos/Shooting.mp4",
-#     "Shoplifting": "static/videos/Shoplifting.mp4", "Stealing": "static/videos/Stealing.mp4",
-#     "Vandalism": "static/videos/Vandalism.mp4", "Normal": "static/videos/Normal.mp4"
-# }
-
-# # --- Thread control ---
-# thread = None
-# thread_lock = threading.Lock()
-# stop_event = threading.Event()
-
-# def smooth_score(scores, new_score, window=5):
-#     scores.append(new_score); scores = scores[-window:]; return float(np.mean(scores))
-
-# # --- Background Task 1 - Save Clip, THEN Schedule Summarizer ---
-# def _save_clip_then_summarize(video_path, clip_dir, initial_frames, fps, width, height):
-#     """
-#     Saves a 30s clip, waits 30 seconds, then starts the summarizer task.
-#     """
-#     out_path = os.path.join(clip_dir, "anomaly_clip.mp4")
-#     save_success = False
-#     try:
-#         socketio.emit('update_status', {'status': 'Saving 30s clip...'})
-#         cap2 = cv2.VideoCapture(video_path)
-#         if not cap2.isOpened(): raise Exception(f"Cannot open video {video_path}")
-
-#         fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-#         out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
-
-#         for f_idx, f in enumerate(initial_frames):
-#             out.write(f)
-#             if f_idx % 5 == 0: socketio.sleep(0.001) # Yield
-
-#         frames_to_save = int(fps * 30)
-#         remaining = frames_to_save - len(initial_frames)
-
-#         for i in range(remaining):
-#             ret, frame = cap2.read()
-#             if not ret: break
-#             out.write(frame)
-#             if i % 5 == 0: socketio.sleep(0.001) # Yield more
-
-#         out.release()
-#         cap2.release()
-#         print(f"✅ [INFO] Saved 30-sec clip -> {out_path}")
-#         save_success = True
-
-#     except Exception as e:
-#         print(f"❌ [ERROR] _save_clip failed: {e}")
-#         socketio.emit('update_summary', {'summary': f"Error saving clip: {e}"})
-#         socketio.emit('recording_signal', {'recording': False}) # Stop recording on error
-
-#     finally:
-#         # --- NEW PLAN: If saving succeeded, wait then summarize ---
-#         if save_success:
-#             try:
-#                 wait_duration = 30 # Seconds to wait
-#                 print(f"⏳ [INFO] Clip saved. Waiting {wait_duration} seconds before starting summarization...")
-#                 socketio.emit('update_status', {'status': f'Clip saved. Waiting {wait_duration}s...'})
-#                 socketio.sleep(wait_duration) # Wait within this background task context
-
-#                 print("🚀 Starting background task for summarization...")
-#                 socketio.emit('update_status', {'status': 'Starting summarizer...'})
-#                 # Start summarizer in a *new* background task
-#                 socketio.start_background_task(_run_summarizer, out_path)
-#             except Exception as e:
-#                  print(f"❌ [ERROR] Failed to start summarizer task after delay: {e}")
-#                  socketio.emit('update_summary', {'summary': f"Error starting summarizer: {e}"})
-#                  socketio.emit('recording_signal', {'recording': False}) # Ensure recording stops
-#         # --- End New Plan ---
-
-
-# # --- Background Task 2 - Just Run Summarizer ---
-# def _run_summarizer(saved_clip_path):
-#     """
-#     Runs the summarizer on the already saved clip. Emits results and recording=False.
-#     """
-#     summary_text = None
-#     try:
-#         print(f"⏳ [INFO] Summarizing clip: {saved_clip_path}")
-#         socketio.emit('update_status', {'status': 'Summarizing clip...'})
-#         socketio.sleep(0.01) # Yield before blocking call
-
-#         api_key_from_env = os.getenv("OPENAI_API_KEY")
-#         if not api_key_from_env: raise ValueError("OPENAI_API_KEY missing.")
-
-#         summary_text = summarize_video(video_path=saved_clip_path, api=api_key_from_env)
-#         print("\n✅ VIDEO SUMMARY (snippet):\n", summary_text[:100] + "...", "\n")
-
-#     except Exception as e:
-#         summary_text = f"Summarizer Error: {e}"
-#         print(f"❌ [ERROR] _run_summarizer failed: {e}")
-#     finally:
-#         if summary_text is None: summary_text = "Summarizer Error: Unknown failure."
-#         socketio.emit('update_summary', {'summary': summary_text})
-#         socketio.emit('recording_signal', {'recording': False}) # Signal recording finished
-#         print("ℹ️ Summarization processing finished.")
-
-
-# # --- Main video processing loop ---
-# def video_processing_task(video_path):
-#     global thread
-#     try:
-#         cap = cv2.VideoCapture(video_path)
-#         if not cap.isOpened(): raise Exception("Cannot open video file")
-
-#         frame_buffer, last_save_time, recent_scores = [], 0.0, []
-#         FRAME_SKIP = 6 # Further increased frame skipping
-#         frame_count = 0
-#         fps, width, height = (cap.get(cv2.CAP_PROP_FPS) or 25.0,
-#                               int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
-#                               int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
-
-#         while cap.isOpened() and not stop_event.is_set():
-#             socketio.sleep(0.002) # Slightly longer sleep in main loop for yielding
-
-#             ret, frame = cap.read()
-#             if not ret: break
-
-#             frame_count += 1
-#             if frame_count % (FRAME_SKIP + 1) != 0: continue # Apply skipping
-
-#             frame_buffer.append(frame.copy())
-
-#             if len(frame_buffer) == 16:
-#                 socketio.sleep(0.001) # Yield before inference
-
-#                 # --- Anomaly Detection ---
-#                 frames_resized = [cv2.resize(f, (112, 112)) for f in frame_buffer]
-#                 clip_np = np.array(frames_resized, dtype=np.uint8)
-#                 clip_torch = torch.from_numpy(clip_np)
-#                 clip_torch = TRANSFORMS(clip_torch).unsqueeze(0).to(DEVICE)
-#                 with torch.no_grad():
-#                     features = feature_extractor(clip_torch).detach()
-#                     score = float(anomaly_detector(features).detach().item())
-#                 score = smooth_score(recent_scores, score)
-#                 score = float(np.clip(score, 0, 1))
-#                 socketio.emit('update_graph', {'score': score})
-#                 # --- End Anomaly Detection ---
-
-#                 # --- Anomaly Actions ---
-#                 now = time.time()
-#                 if score > ANOMALY_THRESHOLD and (now - last_save_time) >= COOLDOWN_SECS:
-#                     print(f"🔥 Anomaly! Score: {score:.2f}")
-#                     last_save_time = now
-
-#                     socketio.emit('recording_signal', {'recording': True})
-#                     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-#                     clip_dir = os.path.join(SAVE_DIR, f"anomaly_{timestamp}")
-#                     os.makedirs(clip_dir, exist_ok=True)
-
-#                     # Quick YOLO
-#                     yolo_frame_path = os.path.join(clip_dir, "yolo_frame.jpg")
-#                     preview_frame_img = frame_buffer[-1].copy()
-#                     cv2.imwrite(yolo_frame_path, preview_frame_img)
-#                     try:
-#                         yolo_result = analyze_video_with_yolo(yolo_frame_path, model_path=YOLO_MODEL_PATH, return_class=True)
-#                         yolo_text = f"🚨 Anomaly → YOLO: {yolo_result}"
-#                     except Exception as e: yolo_text = f"YOLO Error: {e}"
-#                     socketio.emit('update_yolo_text', {'text': yolo_text})
-#                     _, buffer = cv2.imencode('.jpg', preview_frame_img)
-#                     b64_str = base64.b64encode(buffer).decode('utf-8')
-#                     socketio.emit('update_yolo_image', {'image_data': b64_str})
-
-#                     # Signal loading for summary
-#                     socketio.emit('update_summary', {'summary': 'loading'})
-#                     socketio.sleep(0.005) # Yield before starting save task
-
-#                     # Start ONLY the saving task (which will later schedule summarizer)
-#                     print("🚀 Starting background task for clip saving...")
-#                     socketio.start_background_task(
-#                         _save_clip_then_summarize, # Use the new function
-#                         video_path, clip_dir, frame_buffer.copy(),
-#                         fps, width, height
-#                     )
-#                 # --- End anomaly actions ---
-#                 frame_buffer.clear()
-
-#         cap.release()
-#         if not stop_event.is_set(): socketio.emit('processing_finished', {'message': 'Video finished.'})
-#         print("🏁 Video processing task ended.")
-
-#     except Exception as e:
-#          print(f"❌ [ERROR] Unhandled exception in video_processing_task: {e}")
-#          socketio.emit('processing_error', {'error': f'Runtime error: {e}'})
-#     finally:
-#         with thread_lock:
-#             if thread is not None:
-#                  print("🧹 Cleaning up video processing task.")
-#                  thread = None; stop_event.clear()
-
-# # --- (Routes: /, /upload, /video_stream remain the same) ---
-# @app.route('/')
-# def index(): return render_template('index.html', anomaly_names=VIDEO_PATHS.keys())
-
-# @app.route('/upload', methods=['POST'])
-# def upload_file():
-#     if 'video' not in request.files: return jsonify({'error': 'No video file'}), 400
-#     file = request.files['video']; name = file.filename
-#     if name == '': return jsonify({'error': 'No video selected'}), 400
-#     filename = secure_filename(name); ts = datetime.now().strftime('%Y%m%d%H%M%S')
-#     unique_name = f"{ts}_{filename}"; path = os.path.join(app.config['UPLOAD_FOLDER'], unique_name)
-#     try: file.save(path); print(f"✅ Uploaded: {path}"); return jsonify({'success': True, 'filename': unique_name})
-#     except Exception as e: print(f"❌ Upload failed: {e}"); return jsonify({'error': f'{e}'}), 500
-
-# @app.route('/video_stream/<source>/<path:filename>')
-# def video_stream(source, filename):
-#     path, safe_name = None, secure_filename(filename)
-#     if source == 'demo': path = VIDEO_PATHS.get(filename)
-#     elif source == 'upload': path = os.path.join(app.config['UPLOAD_FOLDER'], safe_name)
-#     else: return "Invalid source", 404
-#     if not path or not os.path.exists(path): return "Video not found", 404
-#     def generate():
-#         try:
-#             with open(path, "rb") as f:
-#                 while chunk := f.read(1024*1024): yield chunk; socketio.sleep(0.0001)
-#         except Exception as e: print(f"❌ Streaming error: {e}")
-#     print(f"ℹ️ Streaming: {path}"); return Response(generate(), mimetype="video/mp4")
-
-# # --- (SocketIO handlers: start_processing, reset_system remain the same) ---
-# @socketio.on('start_processing')
-# def handle_start_processing(data):
-#     global thread
-#     with thread_lock:
-#         if thread is None:
-#             stop_event.clear(); source, name = data.get('source'), data.get('filename')
-#             path, safe_name = None, secure_filename(name) if name else None
-#             if not safe_name: return socketio.emit('processing_error', {'error': 'Invalid filename.'})
-#             if source == 'demo': path = VIDEO_PATHS.get(name)
-#             elif source == 'upload': path = os.path.join(app.config['UPLOAD_FOLDER'], safe_name)
-#             if path and os.path.exists(path):
-#                 print(f"🚀 Starting processing: '{safe_name}' ({source})")
-#                 thread = socketio.start_background_task(video_processing_task, path)
-#             else: socketio.emit('processing_error', {'error': 'Video file not found.'})
-#         else: socketio.emit('update_status', {'status': 'Processing already running.'})
-
-# @socketio.on('reset_system')
-# def handle_reset():
-#     global thread
-#     with thread_lock:
-#         if thread: print("🔄 Reset requested. Stopping..."); stop_event.set()
-#         else: print("ℹ️ Reset requested, none running.")
-#     socketio.emit('system_reset_confirm'); print("✅ Reset confirmed.")
-
-# if __name__ == '__main__':
-#     print("🐍 Starting Flask server...")
-#     socketio.run(app, debug=True)
-
-
-#================================================================================================================================================
-
-import os
-import cv2
-import torch
-import numpy as np
-import time
-from datetime import datetime
-import threading
-import base64
-from werkzeug.utils import secure_filename
-
-# --- Load .env file ---
-from dotenv import load_dotenv
-load_dotenv()
-# --- END ---
-
-from flask import Flask, render_template, Response, request, jsonify
-from flask_socketio import SocketIO
-
-# Important: Adjust imports if your structure changed
-from utils.load_model import load_models
-from utils.utils import build_transforms
-from network.TorchUtils import get_torch_device
-from yolo_detection import analyze_video_with_yolo
-from video_sumrrizer import summarize_video # Your summarizer
-
-# ---- App Setup ----
-app = Flask(__name__)
-app.config['SECRET_KEY'] = 'your_secret_key!'
-UPLOAD_FOLDER = 'uploads'
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-socketio = SocketIO(app, async_mode='eventlet')
-
-# ---- Global Config & Model Loading ----
-print("[INFO] Loading models...")
-DEVICE = get_torch_device()
-FEATURE_EXTRACTOR_PATH = "pretrained/c3d.pickle"
-AD_MODEL_PATH = "exps/c3d/models/epoch_80000.pt"
-YOLO_MODEL_PATH = "yolo_my_model.pt"
-SAVE_DIR = "outputs/anomaly_frames"
-ANOMALY_THRESHOLD = 0.4
-COOLDOWN_SECS = 60.0 # <--- This enforces the 60 second anomaly cooldown
-os.makedirs(SAVE_DIR, exist_ok=True)
-
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if not OPENAI_API_KEY: print("⚠️ WARNING: OPENAI_API_KEY not set!")
-
-anomaly_detector, feature_extractor = load_models( FEATURE_EXTRACTOR_PATH, AD_MODEL_PATH, features_method="c3d", device=DEVICE)
-feature_extractor.eval(); anomaly_detector.eval()
-TRANSFORMS = build_transforms(mode="c3d")
-print("[INFO] Models loaded successfully.")
-
-VIDEO_PATHS = { # Ensure these paths are correct relative to app.py
-    "Abuse": "static/videos/Abuse.mp4", "Arrest": "static/videos/Arrest.mp4",
-    "Arson": "static/videos/Arson.mp4", "Assault": "static/videos/Assault.mp4",
-    "Burglary": "static/videos/Burglary.mp4", "Explosion": "static/videos/Explosion.mp4",
-    "Fighting": "static/videos/Fighting.mp4", "RoadAccidents": "static/videos/RoadAccidents.mp4",
-    "Robbery": "static/videos/Robbery.mp4", "Shooting": "static/videos/Shooting.mp4",
-    "Shoplifting": "static/videos/Shoplifting.mp4", "Stealing": "static/videos/Stealing.mp4",
-    "Vandalism": "static/videos/Vandalism.mp4", "Normal": "static/videos/Normal.mp4"
-}
-
-# --- Thread control ---
-thread = None; thread_lock = threading.Lock(); stop_event = threading.Event()
-
-def smooth_score(scores, new_score, window=5):
-    scores.append(new_score); scores = scores[-window:]; return float(np.mean(scores))
-
-# --- MODIFIED: Renamed and removed internal wait ---
-def _save_clip_and_start_summarizer(video_path, clip_dir, initial_frames, fps, width, height):
-    """
-    Saves a 30s clip, then immediately starts the summarizer task.
-    """
-    out_path = os.path.join(clip_dir, "anomaly_clip.mp4")
-    save_success = False
-    try:
-        socketio.emit('update_status', {'status': 'Saving 30s clip...'})
-        cap2 = cv2.VideoCapture(video_path)
-        if not cap2.isOpened(): raise Exception(f"Cannot open video {video_path}")
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
-
-        for f_idx, f in enumerate(initial_frames):
-            out.write(f)
-            if f_idx % 5 == 0: socketio.sleep(0.001)
-
-        frames_to_save = int(fps * 30)
-        remaining = frames_to_save - len(initial_frames)
-
-        for i in range(remaining):
-            ret, frame = cap2.read()
-            if not ret: break
-            out.write(frame)
-            if i % 5 == 0: socketio.sleep(0.001)
-
-        out.release(); cap2.release()
-        print(f"✅ [INFO] Saved 30-sec clip -> {out_path}")
-        save_success = True
-
-    except Exception as e:
-        print(f"❌ [ERROR] _save_clip failed: {e}")
-        socketio.emit('update_summary', {'summary': f"Error saving clip: {e}"})
-        socketio.emit('recording_signal', {'recording': False})
-
-    finally:
-        # --- If saving succeeded, start summarizer immediately ---
-        if save_success:
-            try:
-                print("🚀 Starting background task for summarization...")
-                socketio.emit('update_status', {'status': 'Clip saved. Starting summarizer...'})
-                # Start summarizer in a *new* background task
-                socketio.start_background_task(_run_summarizer, out_path)
-            except Exception as e:
-                 print(f"❌ [ERROR] Failed to start summarizer task: {e}")
-                 socketio.emit('update_summary', {'summary': f"Error starting summarizer: {e}"})
-                 socketio.emit('recording_signal', {'recording': False})
-        # --- End ---
-
-# --- Background Task 2 - Just Run Summarizer (Unchanged) ---
-def _run_summarizer(saved_clip_path):
-    """
-    Runs the summarizer on the already saved clip. Emits results and recording=False.
-    """
-    summary_text = None
-    try:
-        print(f"⏳ [INFO] Summarizing clip: {saved_clip_path}")
-        socketio.emit('update_status', {'status': 'Summarizing clip...'})
-        socketio.sleep(0.01) # Yield before blocking call
-
-        api_key_from_env = os.getenv("OPENAI_API_KEY")
-        if not api_key_from_env: raise ValueError("OPENAI_API_KEY missing.")
-
-        summary_text = summarize_video(video_path=saved_clip_path, api=api_key_from_env)
-        print("\n✅ VIDEO SUMMARY (snippet):\n", summary_text[:100] + "...", "\n")
-
-    except Exception as e:
-        summary_text = f"Summarizer Error: {e}"
-        print(f"❌ [ERROR] _run_summarizer failed: {e}")
-    finally:
-        if summary_text is None: summary_text = "Summarizer Error: Unknown failure."
-        socketio.emit('update_summary', {'summary': summary_text})
-        socketio.emit('recording_signal', {'recording': False}) # Signal recording finished
-        print("ℹ️ Summarization processing finished.")
-
-
-# --- Main video processing loop (Unchanged from previous fix) ---
-def video_processing_task(video_path):
-    global thread
-    try:
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened(): raise Exception("Cannot open video file")
-
-        frame_buffer, last_save_time, recent_scores = [], 0.0, []
-        FRAME_SKIP = 6 # Keep increased frame skipping
-        frame_count = 0
-        fps, width, height = (cap.get(cv2.CAP_PROP_FPS) or 25.0,
-                              int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
-                              int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
-
-        while cap.isOpened() and not stop_event.is_set():
-            socketio.sleep(0.002) # Keep yielding
-
-            ret, frame = cap.read()
-            if not ret: break
-
-            frame_count += 1
-            if frame_count % (FRAME_SKIP + 1) != 0: continue # Apply skipping
-
-            frame_buffer.append(frame.copy())
-
-            if len(frame_buffer) == 16:
-                socketio.sleep(0.001) # Yield before inference
-
-                # --- Anomaly Detection ---
-                frames_resized = [cv2.resize(f, (112, 112)) for f in frame_buffer]
-                clip_np = np.array(frames_resized, dtype=np.uint8)
-                clip_torch = torch.from_numpy(clip_np)
-                clip_torch = TRANSFORMS(clip_torch).unsqueeze(0).to(DEVICE)
-                with torch.no_grad():
-                    features = feature_extractor(clip_torch).detach()
-                    score = float(anomaly_detector(features).detach().item())
-                score = smooth_score(recent_scores, score)
-                score = float(np.clip(score, 0, 1))
-                socketio.emit('update_graph', {'score': score})
-                # --- End Anomaly Detection ---
-
-                # --- Anomaly Actions ---
-                now = time.time()
-                # --- This check enforces the 60 second cooldown ---
-                if score > ANOMALY_THRESHOLD and (now - last_save_time) >= COOLDOWN_SECS:
-                    print(f"🔥 Anomaly! Score: {score:.2f}")
-                    last_save_time = now # Reset cooldown timer
-
-                    socketio.emit('recording_signal', {'recording': True})
-                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                    clip_dir = os.path.join(SAVE_DIR, f"anomaly_{timestamp}")
-                    os.makedirs(clip_dir, exist_ok=True)
-
-                    # Quick YOLO
-                    yolo_frame_path = os.path.join(clip_dir, "yolo_frame.jpg")
-                    preview_frame_img = frame_buffer[-1].copy()
-                    cv2.imwrite(yolo_frame_path, preview_frame_img)
-                    try:
-                        yolo_result = analyze_video_with_yolo(yolo_frame_path, model_path=YOLO_MODEL_PATH, return_class=True)
-                        yolo_text = f"🚨 Anomaly → YOLO: {yolo_result}"
-                    except Exception as e: yolo_text = f"YOLO Error: {e}"
-                    socketio.emit('update_yolo_text', {'text': yolo_text})
-                    _, buffer = cv2.imencode('.jpg', preview_frame_img)
-                    b64_str = base64.b64encode(buffer).decode('utf-8')
-                    socketio.emit('update_yolo_image', {'image_data': b64_str})
-
-                    socketio.emit('update_summary', {'summary': 'loading'})
-                    socketio.sleep(0.005) # Yield before starting save task
-
-                    # Start the saving task (which will later schedule summarizer)
-                    print("🚀 Starting background task for clip saving...")
-                    socketio.start_background_task(
-                        _save_clip_and_start_summarizer, # Use the modified function
-                        video_path, clip_dir, frame_buffer.copy(),
-                        fps, width, height
-                    )
-                # --- End anomaly actions ---
-                frame_buffer.clear()
-
-        cap.release()
-        if not stop_event.is_set(): socketio.emit('processing_finished', {'message': 'Video finished.'})
-        print("🏁 Video processing task ended.")
-
-    except Exception as e:
-         print(f"❌ [ERROR] Unhandled exception in video_processing_task: {e}")
-         socketio.emit('processing_error', {'error': f'Runtime error: {e}'})
-    finally:
-        with thread_lock:
-            if thread is not None:
-                 print("🧹 Cleaning up video processing task.")
-                 thread = None; stop_event.clear()
-
-# --- (Routes: /, /upload, /video_stream remain the same) ---
-@app.route('/')
-def index(): return render_template('index.html', anomaly_names=VIDEO_PATHS.keys())
-
-@app.route('/upload', methods=['POST'])
-def upload_file():
-    if 'video' not in request.files: return jsonify({'error': 'No video file'}), 400
-    file = request.files['video']; name = file.filename
-    if name == '': return jsonify({'error': 'No video selected'}), 400
-    filename = secure_filename(name); ts = datetime.now().strftime('%Y%m%d%H%M%S')
-    unique_name = f"{ts}_{filename}"; path = os.path.join(app.config['UPLOAD_FOLDER'], unique_name)
-    try: file.save(path); print(f"✅ Uploaded: {path}"); return jsonify({'success': True, 'filename': unique_name})
-    except Exception as e: print(f"❌ Upload failed: {e}"); return jsonify({'error': f'{e}'}), 500
-
-@app.route('/video_stream/<source>/<path:filename>')
-def video_stream(source, filename):
-    path, safe_name = None, secure_filename(filename)
-    if source == 'demo': path = VIDEO_PATHS.get(filename)
-    elif source == 'upload': path = os.path.join(app.config['UPLOAD_FOLDER'], safe_name)
-    else: return "Invalid source", 404
-    if not path or not os.path.exists(path): return "Video not found", 404
-    def generate():
-        try:
-            with open(path, "rb") as f:
-                while chunk := f.read(1024*1024): yield chunk; socketio.sleep(0.0001)
-        except Exception as e: print(f"❌ Streaming error: {e}")
-    print(f"ℹ️ Streaming: {path}"); return Response(generate(), mimetype="video/mp4")
-
-# --- (SocketIO handlers: start_processing, reset_system remain the same) ---
-@socketio.on('start_processing')
-def handle_start_processing(data):
-    global thread
-    with thread_lock:
-        if thread is None:
-            stop_event.clear(); source, name = data.get('source'), data.get('filename')
-            path, safe_name = None, secure_filename(name) if name else None
-            if not safe_name: return socketio.emit('processing_error', {'error': 'Invalid filename.'})
-            if source == 'demo': path = VIDEO_PATHS.get(name)
-            elif source == 'upload': path = os.path.join(app.config['UPLOAD_FOLDER'], safe_name)
-            if path and os.path.exists(path):
-                print(f"🚀 Starting processing: '{safe_name}' ({source})")
-                thread = socketio.start_background_task(video_processing_task, path)
-            else: socketio.emit('processing_error', {'error': 'Video file not found.'})
-        else: socketio.emit('update_status', {'status': 'Processing already running.'})
-
-@socketio.on('reset_system')
-def handle_reset():
-    global thread
-    with thread_lock:
-        if thread: print("🔄 Reset requested. Stopping..."); stop_event.set()
-        else: print("ℹ️ Reset requested, none running.")
-    socketio.emit('system_reset_confirm'); print("✅ Reset confirmed.")
-
-if __name__ == '__main__':
-    print("🐍 Starting Flask server...")
+import os
+import cv2
+import torch
+import numpy as np
+import time
+from datetime import datetime
+import threading
+import base64
+from werkzeug.utils import secure_filename
+
+# --- Load .env file ---
+from dotenv import load_dotenv
+load_dotenv()
+# --- END ---
+
+from flask import Flask, render_template, Response, request, jsonify
+from flask_socketio import SocketIO
+
+# Important: Adjust imports if your structure changed
+from utils.load_model import load_models
+from utils.utils import build_transforms
+from network.TorchUtils import get_torch_device
+from yolo_detection import analyze_video_with_yolo
+from video_sumrrizer import summarize_video # Your summarizer
+
+# ---- App Setup ----
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'your_secret_key!'
+UPLOAD_FOLDER = 'uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+socketio = SocketIO(app, async_mode='eventlet')
+
+# ---- Global Config & Model Loading ----
+print("[INFO] Loading models...")
+DEVICE = get_torch_device()
+FEATURE_EXTRACTOR_PATH = "pretrained/c3d.pickle"
+AD_MODEL_PATH = "exps/c3d/models/epoch_80000.pt"
+YOLO_MODEL_PATH = "yolo_my_model.pt"
+SAVE_DIR = "outputs/anomaly_frames"
+ANOMALY_THRESHOLD = 0.4
+COOLDOWN_SECS = 60.0 # <--- This enforces the 60 second anomaly cooldown
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY: print("⚠️ WARNING: OPENAI_API_KEY not set!")
+
+anomaly_detector, feature_extractor = load_models( FEATURE_EXTRACTOR_PATH, AD_MODEL_PATH, features_method="c3d", device=DEVICE)
+feature_extractor.eval(); anomaly_detector.eval()
+TRANSFORMS = build_transforms(mode="c3d")
+print("[INFO] Models loaded successfully.")
+
+VIDEO_PATHS = { # Ensure these paths are correct relative to app.py
+    "Abuse": "static/videos/Abuse.mp4", "Arrest": "static/videos/Arrest.mp4",
+    "Arson": "static/videos/Arson.mp4", "Assault": "static/videos/Assault.mp4",
+    "Burglary": "static/videos/Burglary.mp4", "Explosion": "static/videos/Explosion.mp4",
+    "Fighting": "static/videos/Fighting.mp4", "RoadAccidents": "static/videos/RoadAccidents.mp4",
+    "Robbery": "static/videos/Robbery.mp4", "Shooting": "static/videos/Shooting.mp4",
+    "Shoplifting": "static/videos/Shoplifting.mp4", "Stealing": "static/videos/Stealing.mp4",
+    "Vandalism": "static/videos/Vandalism.mp4", "Normal": "static/videos/Normal.mp4"
+}
+
+# --- Thread control ---
+thread = None; thread_lock = threading.Lock(); stop_event = threading.Event()
+
+def smooth_score(scores, new_score, window=5):
+    scores.append(new_score); scores = scores[-window:]; return float(np.mean(scores))
+
+# --- MODIFIED: Renamed and removed internal wait ---
+def _save_clip_and_start_summarizer(video_path, clip_dir, initial_frames, fps, width, height):
+    """
+    Saves a 30s clip, then immediately starts the summarizer task.
+    """
+    out_path = os.path.join(clip_dir, "anomaly_clip.mp4")
+    save_success = False
+    try:
+        socketio.emit('update_status', {'status': 'Saving 30s clip...'})
+        cap2 = cv2.VideoCapture(video_path)
+        if not cap2.isOpened(): raise Exception(f"Cannot open video {video_path}")
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+
+        for f_idx, f in enumerate(initial_frames):
+            out.write(f)
+            if f_idx % 5 == 0: socketio.sleep(0.001)
+
+        frames_to_save = int(fps * 30)
+        remaining = frames_to_save - len(initial_frames)
+
+        for i in range(remaining):
+            ret, frame = cap2.read()
+            if not ret: break
+            out.write(frame)
+            if i % 5 == 0: socketio.sleep(0.001)
+
+        out.release(); cap2.release()
+        print(f"✅ [INFO] Saved 30-sec clip -> {out_path}")
+        save_success = True
+
+    except Exception as e:
+        print(f"❌ [ERROR] _save_clip failed: {e}")
+        socketio.emit('update_summary', {'summary': f"Error saving clip: {e}"})
+        socketio.emit('recording_signal', {'recording': False})
+
+    finally:
+        # --- If saving succeeded, start summarizer immediately ---
+        if save_success:
+            try:
+                print("🚀 Starting background task for summarization...")
+                socketio.emit('update_status', {'status': 'Clip saved. Starting summarizer...'})
+                # Start summarizer in a *new* background task
+                socketio.start_background_task(_run_summarizer, out_path)
+            except Exception as e:
+                 print(f"❌ [ERROR] Failed to start summarizer task: {e}")
+                 socketio.emit('update_summary', {'summary': f"Error starting summarizer: {e}"})
+                 socketio.emit('recording_signal', {'recording': False})
+        # --- End ---
+
+# --- Background Task 2 - Just Run Summarizer (Unchanged) ---
+def _run_summarizer(saved_clip_path):
+    """
+    Runs the summarizer on the already saved clip. Emits results and recording=False.
+    """
+    summary_text = None
+    try:
+        print(f"⏳ [INFO] Summarizing clip: {saved_clip_path}")
+        socketio.emit('update_status', {'status': 'Summarizing clip...'})
+        socketio.sleep(0.01) # Yield before blocking call
+
+        api_key_from_env = os.getenv("OPENAI_API_KEY")
+        if not api_key_from_env: raise ValueError("OPENAI_API_KEY missing.")
+
+        summary_text = summarize_video(video_path=saved_clip_path, api=api_key_from_env)
+        print("\n✅ VIDEO SUMMARY (snippet):\n", summary_text[:100] + "...", "\n")
+
+    except Exception as e:
+        summary_text = f"Summarizer Error: {e}"
+        print(f"❌ [ERROR] _run_summarizer failed: {e}")
+    finally:
+        if summary_text is None: summary_text = "Summarizer Error: Unknown failure."
+        socketio.emit('update_summary', {'summary': summary_text})
+        socketio.emit('recording_signal', {'recording': False}) # Signal recording finished
+        print("ℹ️ Summarization processing finished.")
+
+
+# --- Main video processing loop (Unchanged from previous fix) ---
+def video_processing_task(video_path):
+    global thread
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened(): raise Exception("Cannot open video file")
+
+        frame_buffer, last_save_time, recent_scores = [], 0.0, []
+        FRAME_SKIP = 6 # Keep increased frame skipping
+        frame_count = 0
+        fps, width, height = (cap.get(cv2.CAP_PROP_FPS) or 25.0,
+                              int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+                              int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
+
+        while cap.isOpened() and not stop_event.is_set():
+            socketio.sleep(0.002) # Keep yielding
+
+            ret, frame = cap.read()
+            if not ret: break
+
+            frame_count += 1
+            if frame_count % (FRAME_SKIP + 1) != 0: continue # Apply skipping
+
+            frame_buffer.append(frame.copy())
+
+            if len(frame_buffer) == 16:
+                socketio.sleep(0.001) # Yield before inference
+
+                # --- Anomaly Detection ---
+                frames_resized = [cv2.resize(f, (112, 112)) for f in frame_buffer]
+                clip_np = np.array(frames_resized, dtype=np.uint8)
+                clip_torch = torch.from_numpy(clip_np)
+                clip_torch = TRANSFORMS(clip_torch).unsqueeze(0).to(DEVICE)
+                with torch.no_grad():
+                    features = feature_extractor(clip_torch).detach()
+                    score = float(anomaly_detector(features).detach().item())
+                score = smooth_score(recent_scores, score)
+                score = float(np.clip(score, 0, 1))
+                socketio.emit('update_graph', {'score': score})
+                # --- End Anomaly Detection ---
+
+                # --- Anomaly Actions ---
+                now = time.time()
+                # --- This check enforces the 60 second cooldown ---
+                if score > ANOMALY_THRESHOLD and (now - last_save_time) >= COOLDOWN_SECS:
+                    print(f"🔥 Anomaly! Score: {score:.2f}")
+                    last_save_time = now # Reset cooldown timer
+
+                    socketio.emit('recording_signal', {'recording': True})
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    clip_dir = os.path.join(SAVE_DIR, f"anomaly_{timestamp}")
+                    os.makedirs(clip_dir, exist_ok=True)
+
+                    # Quick YOLO
+                    yolo_frame_path = os.path.join(clip_dir, "yolo_frame.jpg")
+                    preview_frame_img = frame_buffer[-1].copy()
+                    cv2.imwrite(yolo_frame_path, preview_frame_img)
+                    try:
+                        yolo_result = analyze_video_with_yolo(yolo_frame_path, model_path=YOLO_MODEL_PATH, return_class=True)
+                        yolo_text = f"🚨 Anomaly → YOLO: {yolo_result}"
+                    except Exception as e: yolo_text = f"YOLO Error: {e}"
+                    socketio.emit('update_yolo_text', {'text': yolo_text})
+                    _, buffer = cv2.imencode('.jpg', preview_frame_img)
+                    b64_str = base64.b64encode(buffer).decode('utf-8')
+                    socketio.emit('update_yolo_image', {'image_data': b64_str})
+
+                    socketio.emit('update_summary', {'summary': 'loading'})
+                    socketio.sleep(0.005) # Yield before starting save task
+
+                    # Start the saving task (which will later schedule summarizer)
+                    print("🚀 Starting background task for clip saving...")
+                    socketio.start_background_task(
+                        _save_clip_and_start_summarizer, # Use the modified function
+                        video_path, clip_dir, frame_buffer.copy(),
+                        fps, width, height
+                    )
+                # --- End anomaly actions ---
+                frame_buffer.clear()
+
+        cap.release()
+        if not stop_event.is_set(): socketio.emit('processing_finished', {'message': 'Video finished.'})
+        print("🏁 Video processing task ended.")
+
+    except Exception as e:
+         print(f"❌ [ERROR] Unhandled exception in video_processing_task: {e}")
+         socketio.emit('processing_error', {'error': f'Runtime error: {e}'})
+    finally:
+        with thread_lock:
+            if thread is not None:
+                 print("🧹 Cleaning up video processing task.")
+                 thread = None; stop_event.clear()
+
+# --- (Routes: /, /upload, /video_stream remain the same) ---
+@app.route('/')
+def index(): return render_template('index.html', anomaly_names=VIDEO_PATHS.keys())
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    if 'video' not in request.files: return jsonify({'error': 'No video file'}), 400
+    file = request.files['video']; name = file.filename
+    if name == '': return jsonify({'error': 'No video selected'}), 400
+    filename = secure_filename(name); ts = datetime.now().strftime('%Y%m%d%H%M%S')
+    unique_name = f"{ts}_{filename}"; path = os.path.join(app.config['UPLOAD_FOLDER'], unique_name)
+    try: file.save(path); print(f"✅ Uploaded: {path}"); return jsonify({'success': True, 'filename': unique_name})
+    except Exception as e: print(f"❌ Upload failed: {e}"); return jsonify({'error': f'{e}'}), 500
+
+@app.route('/video_stream/<source>/<path:filename>')
+def video_stream(source, filename):
+    path, safe_name = None, secure_filename(filename)
+    if source == 'demo': path = VIDEO_PATHS.get(filename)
+    elif source == 'upload': path = os.path.join(app.config['UPLOAD_FOLDER'], safe_name)
+    else: return "Invalid source", 404
+    if not path or not os.path.exists(path): return "Video not found", 404
+    def generate():
+        try:
+            with open(path, "rb") as f:
+                while chunk := f.read(1024*1024): yield chunk; socketio.sleep(0.0001)
+        except Exception as e: print(f"❌ Streaming error: {e}")
+    print(f"ℹ️ Streaming: {path}"); return Response(generate(), mimetype="video/mp4")
+
+# --- (SocketIO handlers: start_processing, reset_system remain the same) ---
+@socketio.on('start_processing')
+def handle_start_processing(data):
+    global thread
+    with thread_lock:
+        if thread is None:
+            stop_event.clear(); source, name = data.get('source'), data.get('filename')
+            path, safe_name = None, secure_filename(name) if name else None
+            if not safe_name: return socketio.emit('processing_error', {'error': 'Invalid filename.'})
+            if source == 'demo': path = VIDEO_PATHS.get(name)
+            elif source == 'upload': path = os.path.join(app.config['UPLOAD_FOLDER'], safe_name)
+            if path and os.path.exists(path):
+                print(f"🚀 Starting processing: '{safe_name}' ({source})")
+                thread = socketio.start_background_task(video_processing_task, path)
+            else: socketio.emit('processing_error', {'error': 'Video file not found.'})
+        else: socketio.emit('update_status', {'status': 'Processing already running.'})
+
+@socketio.on('reset_system')
+def handle_reset():
+    global thread
+    with thread_lock:
+        if thread: print("🔄 Reset requested. Stopping..."); stop_event.set()
+        else: print("ℹ️ Reset requested, none running.")
+    socketio.emit('system_reset_confirm'); print("✅ Reset confirmed.")
+
+if __name__ == '__main__':
+    print("🐍 Starting Flask server...")
     socketio.run(app, debug=True)