Deploy latest version to Hugging Face Space

app.py

@@ -23,16 +23,29 @@ from fastapi import WebSocket, WebSocketDisconnect
 import base64
 import cv2
 import time
-from CPR.CPRAnalyzer import CPRAnalyzer
+from CPR.CPRAnalyzer import CPRAnalyzer as OfflineAnalyzer
 import tempfile
 import matplotlib.pyplot as plt
-
-
-
+import json
+import asyncio
+import concurrent.futures
+from CPRRealTime.main import CPRAnalyzer as RealtimeAnalyzer
+from threading import Thread
+from starlette.responses import StreamingResponse
+import threading
+import queue
+from CPRRealTime.analysis_socket_server import AnalysisSocketServer  # adjust if needed
+from CPRRealTime.logging_config import cpr_logger
+import logging
+import sys
+import re
+import signal
 
 
 app = FastAPI()
 
+SCREENSHOTS_DIR = "screenshots"  # Folder containing screenshots to upload
+OUTPUT_DIR = "Output"            # Folder containing the .mp4 video and graph .png
 UPLOAD_DIR = "uploads"
 os.makedirs(UPLOAD_DIR, exist_ok=True)
 
@@ -44,18 +57,7 @@ except Exception as e:
     print(f"❌ Model loading failed: {str(e)}")
     model = None
 
-# ✅ MongoDB connection
-mongo_uri = "mongodb://husseinelhadidy03:W8ByXdBS4EFkZmd5@ac-lqfhgnk-shard-00-00.ycuagnj.mongodb.net:27017,ac-lqfhgnk-shard-00-01.ycuagnj.mongodb.net:27017,ac-lqfhgnk-shard-00-02.ycuagnj.mongodb.net:27017/?replicaSet=atlas-az5d0x-shard-0&ssl=true&authSource=admin&retryWrites=true&w=majority&appName=Cluster0"
-client = MongoClient(mongo_uri, server_api=ServerApi('1'))
 
-try:
-    client.admin.command('ping')
-    print("✅ Successfully connected to MongoDB!")
-except Exception as e:
-    print("❌ MongoDB connection failed:", e)
-
-# ✅ Use a shared database instance
-db = client["El7a2ny"]
 
 # ✅ Cloudinary config
 cloudinary.config( 
@@ -65,35 +67,11 @@ cloudinary.config(
     secure=True
 )
 
-# ✅ Basic Hello route
+# Basic Hello route
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}
 
-# ✅ MongoDB document count route for Images collection
-@app.get("/count")
-def count_docs():
-    collection = db["Images"]
-    count = collection.count_documents({})
-    return {"document_count": count}
-
-# ✅ Upload image to Cloudinary and save URL to MongoDB
-@app.post("/cloudinary/upload")
-async def upload_sample(file: UploadFile = File(...)):
-    try:
-        # Upload the file to Cloudinary
-        result = cloudinary.uploader.upload(file.file, public_id=file.filename)
-        uploaded_url = result["secure_url"]
-
-        # Save image URL to MongoDB
-        collection = db["Images"]
-        doc = {"filename": file.filename, "url": uploaded_url}
-        collection.insert_one(doc)
-
-        return {"uploaded_url": uploaded_url}
-    except Exception as e:
-        return {"error": str(e)}
-    
 @app.post("/predict_burn")
 async def predict_burn(file: UploadFile = File(...)):
     try:
@@ -102,10 +80,6 @@ async def predict_burn(file: UploadFile = File(...)):
         with open(temp_file_path, "wb") as temp_file:
             temp_file.write(await file.read())
 
-        # Upload the file to Cloudinary
-        #upload_result = cloudinary.uploader.upload(temp_file_path, public_id=f"predict_{file.filename}")
-        #cloudinary_url = upload_result["secure_url"]
-        cloudinary_url = "https:facebook.com"
 
         # Load the saved SVM model
         with open('svm_model.pkl', 'rb') as model_file:
@@ -133,21 +107,14 @@ async def predict_burn(file: UploadFile = File(...)):
             prediction_label = "Second Class"
         else:
             prediction_label = "Zero Class"
-
-        # Save result to MongoDB
-        #collection = db["Predictions"]
-        #doc = {"filename": file.filename, "url": cloudinary_url, "prediction": prediction_label}
-        #collection.insert_one(doc)
             
         return {
-            "prediction": prediction_label,
-            "image_url": cloudinary_url
+            "prediction": prediction_label
         }
 
     except Exception as e:
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
-
 @app.post("/segment_burn")
 async def segment_burn_endpoint(reference: UploadFile = File(...), patient: UploadFile = File(...)):
     try:
@@ -184,7 +151,7 @@ async def segment_burn_endpoint(reference: UploadFile = File(...), patient: Uplo
         
         os.remove(burn_crop_clean_path)
         os.remove(burn_crop_debug_path)
-        
+
 
         return {
             "crop_clean_url": crop_clean_url,
@@ -195,19 +162,6 @@ async def segment_burn_endpoint(reference: UploadFile = File(...), patient: Uplo
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
 
-# ✅ Optimize and transform image URL
-@app.get("/cloudinary/transform")
-def transform_image():
-    try:
-        optimized_url, _ = cloudinary_url("shoes", fetch_format="auto", quality="auto")
-        auto_crop_url, _ = cloudinary_url("shoes", width=500, height=500, crop="auto", gravity="auto")
-        return {
-            "optimized_url": optimized_url,
-            "auto_crop_url": auto_crop_url
-        }
-    except Exception as e:
-        return {"error": str(e)}
-    
 @app.post("/classify-ecg")
 async def classify_ecg_endpoint(file: UploadFile = File(...)):
     model = joblib.load('voting_classifier.pkl')
@@ -229,8 +183,7 @@ async def classify_ecg_endpoint(file: UploadFile = File(...)):
 
     except Exception as e:
         return JSONResponse(content={"error": str(e)}, status_code=500)
-
-
+    
 @app.post("/diagnose-ecg")
 async def diagnose_ecg(file: UploadFile = File(...)):
     try:
@@ -266,6 +219,17 @@ async def diagnose_ecg(file: UploadFile = File(...)):
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
 
+def clean_warning_name(filename: str) -> str:
+    """
+    Remove frame index and underscores from filename base
+    E.g. "posture_001.png" -> "posture"
+    """
+    name, _ = os.path.splitext(filename)
+    # Remove trailing underscore + digits
+    cleaned = re.sub(r'_\d+$', '', name)
+    # Remove all underscores in the name for description
+    cleaned_desc = cleaned.replace('_', ' ')
+    return cleaned, cleaned_desc
 
 @app.post("/process_video")
 async def process_video(file: UploadFile = File(...)):
@@ -275,159 +239,309 @@ async def process_video(file: UploadFile = File(...)):
     print("File content type:", file.content_type)
     print("File filename:", file.filename)
 
-    # Save uploaded file
+    # Prepare directories
+    os.makedirs(UPLOAD_DIR, exist_ok=True)
+    os.makedirs(SCREENSHOTS_DIR, exist_ok=True)
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    folders = ["screenshots", "uploads", "Output"]
+
+    for folder in folders:
+        if os.path.exists(folder):
+            for filename in os.listdir(folder):
+                file_path = os.path.join(folder, filename)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+
+    # Save uploaded video file
     video_path = os.path.join(UPLOAD_DIR, file.filename)
     with open(video_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
 
-    print("[START] CPR Analysis started")
-    start_time = time.time()
-
-    cap = cv2.VideoCapture(video_path)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    duration_seconds = total_frames / fps
-    chunk_duration = 10  # seconds
-    frames_per_chunk = int(fps * chunk_duration)
-
-    chunks = []
-    chunk_index = 0
-    current_frame = 0
-
-    while current_frame < total_frames:
-        # Read the chunk into memory
-        frames = []
-        for _ in range(frames_per_chunk):
-            ret, frame = cap.read()
-            if not ret:
-                break
-            frames.append(frame)
-            current_frame += 1
-
-        if not frames:
-            break
-
-        # Save chunk to temp video
-        temp_chunk_path = os.path.join(tempfile.gettempdir(), f"chunk_{chunk_index}.mp4")
-        height, width = frames[0].shape[:2]
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(temp_chunk_path, fourcc, fps, (width, height))
-        for f in frames:
-            out.write(f)
-        out.release()
-
-        # Analyze chunk
-        print(f"[CHUNK {chunk_index}] Processing chunk at {temp_chunk_path}")
-        analyzer = CPRAnalyzer(temp_chunk_path)
-        analyzer.run_analysis()
+    print(f"\n[API] CPR Analysis Started on {video_path}")
 
-        # Gather results
-        metrics = analyzer.get_compression_metrics()
-        warnings = analyzer.get_posture_warning_results()
+    # Prepare output paths for the analyzer
+    video_output_path = os.path.join(OUTPUT_DIR, "Myoutput.mp4")
+    plot_output_path = os.path.join(OUTPUT_DIR, "Myoutput.png")
 
-                # Upload each warning to cloudinary
-        for w in warnings:
-            local_path = w['image_url']
-            upload_result = cloudinary.uploader.upload(local_path, folder="posture_warnings")
-            w['image_url'] = upload_result['secure_url']
+    # Initialize analyzer with input video and output paths
+    start_time = time.time()
+    analyzer = OfflineAnalyzer(video_path, video_output_path, plot_output_path, requested_fps=30)
+
+    # Run the analysis (choose your method)
+    chunks = analyzer.run_analysis_video()
+
+    warnings = []  # Start empty list
+
+    # Upload screenshots and build warnings list with descriptions and URLs
+    if os.path.exists(SCREENSHOTS_DIR):
+        for filename in os.listdir(SCREENSHOTS_DIR):
+            if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+                local_path = os.path.join(SCREENSHOTS_DIR, filename)
+                cleaned_name, description = clean_warning_name(filename)
+
+                upload_result = cloudinary.uploader.upload(
+                    local_path,
+                    folder="posture_warnings",
+                    public_id=cleaned_name,
+                    overwrite=True
+                )
+
+                # Add new warning with image_url and description
+                warnings.append({
+                    "image_url": upload_result['secure_url'],
+                    "description": description
+                })
+
+    video_path = "Output/Myoutput_final.mp4"
+
+    if os.path.isfile(video_path):
+        upload_result = cloudinary.uploader.upload_large(
+            video_path,
+            resource_type="video",
+            folder="output_videos",
+            public_id="Myoutput_final",
+            overwrite=True
+        )
+        wholevideoURL = upload_result['secure_url']
+    else:
+        wholevideoURL = None
+
+    # Upload graph output
+    graphURL = None
+    if os.path.isfile(plot_output_path):
+        upload_graph_result = cloudinary.uploader.upload(
+            plot_output_path,
+            folder="output_graphs",
+            public_id=os.path.splitext(os.path.basename(plot_output_path))[0],
+            overwrite=True
+        )
+        graphURL = upload_graph_result['secure_url']
 
-        # Estimate score (adjust this logic as needed)
-        penalty = len(warnings) * 0.1
-        rate_score = min(metrics["average_compression_rate"] / 120, 1.0)
-        depth_score = min(metrics["average_compression_depth"] / 5.0, 1.0)
-        average_score = max(0.0, (rate_score + depth_score)/2 - penalty)
+    print(f"[API] CPR Analysis Completed on {video_path}")
+    analysis_time = time.time() - start_time
+    print(f"[TIMING] Analysis time: {analysis_time:.2f}s")
 
-        chunks.append({
-            "average_score": round(average_score, 2),
-            "average_rate": round(metrics["average_compression_rate"], 1),
-            "average_depth": round(metrics["average_compression_depth"], 1),
-            "posture_warnings": warnings
-        })
+    if wholevideoURL is None:
+        raise HTTPException(status_code=500, detail="No chunk data was generated from the video.")
 
-        chunk_index += 1
+    return JSONResponse(content={
+        "videoURL": wholevideoURL,
+        "graphURL": graphURL,
+        "warnings": warnings,
+        "chunks": chunks,
+    })
 
-    cap.release()
-    print(f"[END] Total processing time: {time.time() - start_time:.2f}s")
 
-    return JSONResponse(content={"chunks": chunks})
+# @app.websocket("/ws/process_video")
+# async def websocket_process_video(websocket: WebSocket):
+
+#     await websocket.accept()
+
+#     frame_buffer = []
+#     frame_limit = 50
+#     frame_size = (640, 480)  # Adjust if needed
+#     fps = 30  # Adjust if needed
+#     loop = asyncio.get_event_loop()
+
+#     # Progress reporting during analysis
+#     async def progress_callback(data):
+#         await websocket.send_text(json.dumps(data))
+
+#     def sync_callback(data):
+#         asyncio.run_coroutine_threadsafe(progress_callback(data), loop)
+
+#     def save_frames_to_video(frames, path):
+#         out = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*'mp4v'), fps, frame_size)
+#         for frame in frames:
+#             resized = cv2.resize(frame, frame_size)
+#             out.write(resized)
+#         out.release()
+
+#     def run_analysis_on_buffer(frames):
+#         try:
+#             tmp_path = "temp_video.mp4"
+#             save_frames_to_video(frames, tmp_path)
+
+#             # Notify: video saved
+#             asyncio.run_coroutine_threadsafe(
+#                 websocket.send_text(json.dumps({
+#                     "status": "info",
+#                     "message": "Video saved. Starting CPR analysis..."
+#                 })),
+#                 loop
+#             )
+
+#             # Run analysis
+#             analyzer = CPRAnalyzer(video_path=tmp_path)
+#             analyzer.run_analysis(progress_callback=sync_callback)
+
+#         except Exception as e:
+#             asyncio.run_coroutine_threadsafe(
+#                 websocket.send_text(json.dumps({"error": str(e)})),
+#                 loop
+#             )
+
+#     try:
+#         while True:
+#             data: bytes = await websocket.receive_bytes()
+#             np_arr = np.frombuffer(data, np.uint8)
+#             frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+#             if frame is None:
+#                 continue
+
+#             frame_buffer.append(frame)
+#             print(f"Frame added to buffer: {len(frame_buffer)}")
+
+#             if len(frame_buffer) == frame_limit:
+#                 # Notify Flutter that we're switching to processing
+#                 await websocket.send_text(json.dumps({
+#                     "status": "ready",
+#                     "message": "Prepare Right CPR: First 150 frames received. Starting processing."
+#                 }))
+
+#                 # Copy and clear buffer
+#                 buffer_copy = frame_buffer[:]
+#                 frame_buffer.clear()
+
+#                 # Launch background processing
+#                 executor = concurrent.futures.ThreadPoolExecutor()
+#                 loop.run_in_executor(executor, run_analysis_on_buffer, buffer_copy)
+#             else:
+#                 # Tell Flutter to send the next frame
+#                 await websocket.send_text(json.dumps({
+#                     "status": "continue",
+#                     "message": f"Frame {len(frame_buffer)} received. Send next."
+#                 }))
+
+#     except WebSocketDisconnect:
+#         print("Client disconnected")
+
+#     except Exception as e:
+#         await websocket.send_text(json.dumps({"error": str(e)}))
+
+#     finally:
+#         cv2.destroyAllWindows()
+
+
+logger = logging.getLogger("cpr_logger")
+clients = set()
+analyzer_thread = None
+analysis_started = False
+analyzer_lock = threading.Lock()
+socket_server: AnalysisSocketServer = None  # Global reference
+
+
+async def forward_results_from_queue(websocket: WebSocket, warning_queue):
+    try:
+        while True:
+            warnings = await asyncio.to_thread(warning_queue.get)
+            serialized = json.dumps(warnings)
+            await websocket.send_text(serialized)
+    except asyncio.CancelledError:
+        logger.info("[WebSocket] Forwarding task cancelled")
+    except Exception as e:
+        logger.error(f"[WebSocket] Error forwarding data: {e}")
 
 
-@app.post("/process_image")
-async def process_image(file: UploadFile = File(...)):
-    if not file.content_type.startswith("image/"):
-        raise HTTPException(status_code=400, detail="File must be an image.")
+def run_cpr_analysis(source, requested_fps, output_path):
+    global socket_server
+    logger.info(f"[MAIN] CPR Analysis Started")
 
-    print("File content type:", file.content_type)
-    print("File filename:", file.filename)
+    requested_fps = 30
+    input_video = source
 
-    # Save uploaded image
-    image_path = os.path.join(UPLOAD_DIR, file.filename)
-    with open(image_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
+    output_dir = r"D:\BackendGp\Deploy_El7a2ny_Application\CPRRealTime\outputs"
+    os.makedirs(output_dir, exist_ok=True)
 
-  
+    video_output_path = os.path.join(output_dir, "output.mp4")
+    plot_output_path = os.path.join(output_dir, "output.png")
 
-    # Run YOLO detection on the image
-    try:
-        results = model(
-            source=image_path,
-            show=False,
-            save=False
-        )
+    logger.info(f"[CONFIG] Input video: {input_video}")
+    logger.info(f"[CONFIG] Video output: {video_output_path}")
+    logger.info(f"[CONFIG] Plot output: {plot_output_path}")
 
-        if not results or len(results) == 0 or results[0].keypoints is None or results[0].keypoints.xy is None:
-            return JSONResponse(content={"message": "No keypoints detected"}, status_code=200)
+    initialization_start_time = time.time()
+    analyzer = RealtimeAnalyzer(input_video, video_output_path, plot_output_path, requested_fps)
+    socket_server = analyzer.socket_server
+    analyzer.plot_output_path = plot_output_path
 
-        keypoints = results[0].keypoints.xy
-        confidences = results[0].boxes.conf if results[0].boxes is not None else []
+    elapsed_time = time.time() - initialization_start_time
+    logger.info(f"[TIMING] Initialization time: {elapsed_time:.2f}s")
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"YOLO processing error: {str(e)}")
+    try:
+        analyzer.run_analysis()
+    finally:
+        if analyzer.socket_server:
+            analyzer.socket_server.stop_server()
+        logger.info("[MAIN] Analyzer stopped")
 
-    return JSONResponse(content={
-        "message": "Image processed successfully",
-        "KeypointsXY": keypoints.tolist(),
-        "confidences": confidences.tolist()
-    })
 
+@app.websocket("/ws/real")
+async def websocket_analysis(websocket: WebSocket):
+    global analyzer_thread, analysis_started, socket_server
 
-# WebSocket endpoint to handle image processing
-@app.websocket("/ws/image")
-async def websocket_endpoint(websocket: WebSocket):
-    model = YOLO("yolo11n-pose_float16.tflite")
-    print("Model loaded successfully")
     await websocket.accept()
+    clients.add(websocket)
+    logger.info("[WebSocket] Flutter connected")
+
     try:
+        # Wait for the client to send the stream URL as first message
+        source = await websocket.receive_text()
+        logger.info(f"[WebSocket] Received stream URL: {source}")
+
+        # Ensure analyzer starts only once using a thread-safe lock
+        with analyzer_lock:
+            if not analysis_started:
+                requested_fps = 30
+                output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
+
+                analyzer_thread = threading.Thread(
+                    target=run_cpr_analysis,
+                    args=(source, requested_fps, output_path),
+                    daemon=True
+                )
+                analyzer_thread.start()
+                analysis_started = True
+                logger.info("[WebSocket] Analysis thread started")
+
+        # Rest of your existing code remains exactly the same...
+        while socket_server is None or socket_server.warning_queue is None:
+            await asyncio.sleep(0.1)
+
+        forward_task = asyncio.create_task(
+            forward_results_from_queue(websocket, socket_server.warning_queue)
+        )
+
         while True:
-            data = await websocket.receive_text()  # Receive base64-encoded image data
-            image_data = base64.b64decode(data)  # Decode the image data
+            await asyncio.sleep(1)  # Keep alive
 
-            # Convert image bytes to numpy array and decode with OpenCV
-            np_arr = np.frombuffer(image_data, np.uint8)
-            frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-            
-            # Run YOLO pose estimation
-            if model is not None:
-                try:
-                    results = model.predict(frame, save=False, conf=0.3)
-                    
-                    if results and results[0].keypoints:
-                        keypoints = results[0].keypoints.xy.cpu().numpy().tolist()  # Extract keypoints
-                        confidences = results[0].boxes.conf.cpu().numpy().tolist() if results[0].boxes else []
-
-                        # Send the results back to the client
-                        response = {
-                            "message": "Pose detected",
-                            "KeypointsXY": keypoints[:5],  # Limit to first 5 keypoints for brevity
-                            "Confidences": confidences[:5],  # Limit to first 5 confidences
-                        }
-                        await websocket.send_text(str(response))
-                    else:
-                        await websocket.send_text("❌ No keypoints detected.")
-                except Exception as e:
-                    await websocket.send_text(f"⚠️ Error processing image: {str(e)}")
-            else:
-                await websocket.send_text("⚠️ Model not loaded.")
-                
     except WebSocketDisconnect:
-        print("🔌 Client disconnected")
+        logger.warning("[WebSocket] Client disconnected")
+        if 'forward_task' in locals():
+            forward_task.cancel()
+    except Exception as e:
+        logger.error(f"[WebSocket] Error receiving stream URL: {str(e)}")
+        await websocket.close(code=1011)  # 1011 = Internal Error
+    finally:
+        clients.discard(websocket)
+        logger.info(f"[WebSocket] Active clients: {len(clients)}")
+
+        if not clients and socket_server:
+            logger.info("[WebSocket] No clients left. Stopping analyzer.")
+            socket_server.stop_server()
+            analysis_started = False
+            socket_server = None
+
+
+def shutdown_handler(signum, frame):
+    logger.info("Received shutdown signal")
+    if socket_server:
+        try:
+            socket_server.stop_server()
+        except Exception as e:
+            logger.warning(f"Error during socket server shutdown: {e}")
+    os._exit(0)
+
+signal.signal(signal.SIGINT, shutdown_handler)
+signal.signal(signal.SIGTERM, shutdown_handler)

main.py

@@ -39,6 +39,7 @@ from CPRRealTime.logging_config import cpr_logger
 import logging
 import sys
 import re
+import signal
 
 
 app = FastAPI()
@@ -56,18 +57,7 @@ except Exception as e:
     print(f"❌ Model loading failed: {str(e)}")
     model = None
 
-# ✅ MongoDB connection
-mongo_uri = "mongodb://husseinelhadidy03:W8ByXdBS4EFkZmd5@ac-lqfhgnk-shard-00-00.ycuagnj.mongodb.net:27017,ac-lqfhgnk-shard-00-01.ycuagnj.mongodb.net:27017,ac-lqfhgnk-shard-00-02.ycuagnj.mongodb.net:27017/?replicaSet=atlas-az5d0x-shard-0&ssl=true&authSource=admin&retryWrites=true&w=majority&appName=Cluster0"
-client = MongoClient(mongo_uri, server_api=ServerApi('1'))
 
-try:
-    client.admin.command('ping')
-    print("✅ Successfully connected to MongoDB!")
-except Exception as e:
-    print("❌ MongoDB connection failed:", e)
-
-# ✅ Use a shared database instance
-db = client["El7a2ny"]
 
 # ✅ Cloudinary config
 cloudinary.config( 
@@ -77,7 +67,7 @@ cloudinary.config(
     secure=True
 )
 
-# ✅ Basic Hello route
+# Basic Hello route
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}
@@ -90,10 +80,6 @@ async def predict_burn(file: UploadFile = File(...)):
         with open(temp_file_path, "wb") as temp_file:
             temp_file.write(await file.read())
 
-        # Upload the file to Cloudinary
-        #upload_result = cloudinary.uploader.upload(temp_file_path, public_id=f"predict_{file.filename}")
-        #cloudinary_url = upload_result["secure_url"]
-        cloudinary_url = "https:facebook.com"
 
         # Load the saved SVM model
         with open('svm_model.pkl', 'rb') as model_file:
@@ -121,15 +107,9 @@ async def predict_burn(file: UploadFile = File(...)):
             prediction_label = "Second Class"
         else:
             prediction_label = "Zero Class"
-
-        # Save result to MongoDB
-        #collection = db["Predictions"]
-        #doc = {"filename": file.filename, "url": cloudinary_url, "prediction": prediction_label}
-        #collection.insert_one(doc)
             
         return {
-            "prediction": prediction_label,
-            "image_url": cloudinary_url
+            "prediction": prediction_label
         }
 
     except Exception as e:
@@ -444,8 +424,6 @@ async def process_video(file: UploadFile = File(...)):
 #         cv2.destroyAllWindows()
 
 
-
-
 logger = logging.getLogger("cpr_logger")
 clients = set()
 analyzer_thread = None
@@ -507,42 +485,48 @@ async def websocket_analysis(websocket: WebSocket):
     clients.add(websocket)
     logger.info("[WebSocket] Flutter connected")
 
-    # Ensure analyzer starts only once using a thread-safe lock
-    with analyzer_lock:
-        if not analysis_started:
-            source = "http://192.168.137.244:8080/video"
-            requested_fps = 30
-            output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
-
-            analyzer_thread = threading.Thread(
-                target=run_cpr_analysis,
-                args=(source, requested_fps, output_path),
-                daemon=True
-            )
-            analyzer_thread.start()
-            analysis_started = True
-            logger.info("[WebSocket] Analysis thread started")
-
-    # Wait until the socket server and queue are initialized
-    while socket_server is None or socket_server.warning_queue is None:
-        await asyncio.sleep(0.1)
-
-    # Start async task to stream data to client
-    forward_task = asyncio.create_task(
-        forward_results_from_queue(websocket, socket_server.warning_queue)
-    )
-
     try:
+        # Wait for the client to send the stream URL as first message
+        source = await websocket.receive_text()
+        logger.info(f"[WebSocket] Received stream URL: {source}")
+
+        # Ensure analyzer starts only once using a thread-safe lock
+        with analyzer_lock:
+            if not analysis_started:
+                requested_fps = 30
+                output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
+
+                analyzer_thread = threading.Thread(
+                    target=run_cpr_analysis,
+                    args=(source, requested_fps, output_path),
+                    daemon=True
+                )
+                analyzer_thread.start()
+                analysis_started = True
+                logger.info("[WebSocket] Analysis thread started")
+
+        # Rest of your existing code remains exactly the same...
+        while socket_server is None or socket_server.warning_queue is None:
+            await asyncio.sleep(0.1)
+
+        forward_task = asyncio.create_task(
+            forward_results_from_queue(websocket, socket_server.warning_queue)
+        )
+
         while True:
             await asyncio.sleep(1)  # Keep alive
+
     except WebSocketDisconnect:
         logger.warning("[WebSocket] Client disconnected")
-        forward_task.cancel()
+        if 'forward_task' in locals():
+            forward_task.cancel()
+    except Exception as e:
+        logger.error(f"[WebSocket] Error receiving stream URL: {str(e)}")
+        await websocket.close(code=1011)  # 1011 = Internal Error
     finally:
         clients.discard(websocket)
         logger.info(f"[WebSocket] Active clients: {len(clients)}")
 
-        # Optional: stop analysis if no clients remain
         if not clients and socket_server:
             logger.info("[WebSocket] No clients left. Stopping analyzer.")
             socket_server.stop_server()
@@ -550,8 +534,6 @@ async def websocket_analysis(websocket: WebSocket):
             socket_server = None
 
 
-import signal
-
 def shutdown_handler(signum, frame):
     logger.info("Received shutdown signal")
     if socket_server: