Spaces:

tejovk311
/

esp_server

Sleeping

App Files Files Community

tejovk311 commited on Jun 23, 2025

Commit

ef5e09b

verified ·

1 Parent(s): a99dbb2

Update app.py

Browse files

Files changed (1) hide show

app.py +1 -1105

app.py CHANGED Viewed

@@ -166,162 +166,6 @@ def vitals_data():
     response = requests.get(url, headers=headers, params=params)
     return jsonify(response.json()) if response.status_code == 200 else jsonify({"error": response.text}), 500
-# @app.route('/dashboard')
-# def dashboard():
-#     html = '''
-#     <!DOCTYPE html>
-#     <html>
-#     <head>
-#         <title>Vitals Dashboard</title>
-#         <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
-#         <style>
-#             body {
-#                 font-family: Arial, sans-serif;
-#                 padding: 10px;
-#                 background: #f4f6f9;
-#                 margin: 0;
-#             }
-#             h2 {
-#                 text-align: center;
-#                 margin-bottom: 10px;
-#             }
-#             .input-container {
-#                 text-align: center;
-#                 margin-bottom: 15px;
-#             }
-#             input, button {
-#                 padding: 8px;
-#                 font-size: 14px;
-#                 margin: 5px;
-#             }
-#             .grid-container {
-#                 display: grid;
-#                 grid-template-columns: 1fr 1fr;
-#                 gap: 10px;
-#             }
-#             .chart-box {
-#                 background: #fff;
-#                 border-radius: 8px;
-#                 padding: 5px;
-#                 box-shadow: 0 1px 6px rgba(0,0,0,0.1);
-#                 height: 300px;
-#             }
-#         </style>
-#     </head>
-#     <body>
-#         <h2>Vitals Dashboard (Filter by MRD)</h2>
-#         <div class="input-container">
-#             <input type="text" id="mrd" placeholder="Enter MRD number" />
-#             <button onclick="loadData()">Load</button>
-#         </div>
-#         <div class="grid-container">
-#             <div class="chart-box" id="hr_chart"></div>
-#             <div class="chart-box" id="rr_chart"></div>
-#             <div class="chart-box" id="spo2_chart"></div>
-#             <div class="chart-box" id="bp_chart"></div>
-#         </div>
-#         <script>
-#             async function loadData() {
-#                 const mrd = document.getElementById("mrd").value.trim();
-#                 if (!mrd) return alert("Please enter an MRD number.");
-#                 const res = await fetch(`/vitals_data?mrd=${mrd}`);
-#                 const data = await res.json();
-#                 const timestamps = [], hr = [], rr = [], spo2 = [], sys = [], dia = [];
-#                 for (let v of data) {
-#                     timestamps.push(v.timestamp);
-#                     hr.push(v.heart_rate);
-#                     rr.push(v.respiratory_rate);
-#                     spo2.push(v.oxygen_saturation);
-#                     if (v.blood_pressure && v.blood_pressure.includes("/")) {
-#                         const [s, d] = v.blood_pressure.split("/");
-#                         sys.push(parseInt(s));
-#                         dia.push(parseInt(d));
-#                     } else {
-#                         sys.push(null);
-#                         dia.push(null);
-#                     }
-#                 }
-#                 // Layouts with fixed y-axis ranges
-#                 const layoutHR = {
-#                     title: "Heart Rate",
-#                     height: 280,
-#                     margin: { t: 30, l: 40, r: 20, b: 40 },
-#                     xaxis: { title: "Time", tickangle: -45 },
-#                     yaxis: { title: "bpm", range: [40, 130] }
-#                 };
-#                 const layoutRR = {
-#                     title: "Respiratory Rate",
-#                     height: 280,
-#                     margin: { t: 30, l: 40, r: 20, b: 40 },
-#                     xaxis: { title: "Time", tickangle: -45 },
-#                     yaxis: { title: "breaths/min", range: [5, 30] }
-#                 };
-#                 const layoutSpO2 = {
-#                     title: "Oxygen Saturation",
-#                     height: 280,
-#                     margin: { t: 30, l: 40, r: 20, b: 40 },
-#                     xaxis: { title: "Time", tickangle: -45 },
-#                     yaxis: { title: "%", range: [60, 100] }
-#                 };
-#                 const layoutBP = {
-#                     title: "Blood Pressure",
-#                     height: 280,
-#                     margin: { t: 30, l: 40, r: 20, b: 40 },
-#                     xaxis: { title: "Time", tickangle: -45 },
-#                     yaxis: { title: "mmHg", range: [40, 200] }
-#                 };
-#                 Plotly.newPlot("hr_chart", [{
-#                     x: timestamps,
-#                     y: hr,
-#                     name: "Heart Rate",
-#                     type: "scatter",
-#                     mode: "lines+markers"
-#                 }], layoutHR);
-#                 Plotly.newPlot("rr_chart", [{
-#                     x: timestamps,
-#                     y: rr,
-#                     name: "Respiratory Rate",
-#                     type: "scatter",
-#                     mode: "lines+markers"
-#                 }], layoutRR);
-#                 Plotly.newPlot("spo2_chart", [{
-#                     x: timestamps,
-#                     y: spo2,
-#                     name: "Oxygen Saturation",
-#                     type: "scatter",
-#                     mode: "lines+markers"
-#                 }], layoutSpO2);
-#                 Plotly.newPlot("bp_chart", [
-#                     {
-#                         x: timestamps,
-#                         y: sys,
-#                         name: "Systolic",
-#                         type: "scatter",
-#                         mode: "lines+markers"
-#                     },
-#                     {
-#                         x: timestamps,
-#                         y: dia,
-#                         name: "Diastolic",
-#                         type: "scatter",
-#                         mode: "lines+markers"
-#                     }
-#                 ], layoutBP);
-#             }
-#         </script>
-#     </body>
-#     </html>
-#     '''
-#     return render_template_string(html)
 @app.route('/dashboard')
 def dashboard():
@@ -470,952 +314,4 @@ def dashboard():
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
-# # # # # from flask import Flask, request, send_from_directory, render_template_string
-# # # # # import os
-# # # # # from datetime import datetime
-# # # # # app = Flask(__name__)
-# # # # # UPLOAD_FOLDER = '/tmp/received_images'
-# # # # # os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# # # # # latest_filename = None  # Store the latest uploaded filename globally
-# # # # # @app.route('/upload', methods=['POST'])
-# # # # # def upload_file():
-# # # # #     global latest_filename
-# # # # #     img_data = request.data
-# # # # #     filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpeg"
-# # # # #     filepath = os.path.join(UPLOAD_FOLDER, filename)
-# # # # #     with open(filepath, 'wb') as f:
-# # # # #         f.write(img_data)
-# # # # #     latest_filename = filename
-# # # # #     return 'OK', 200
-# # # # # @app.route('/images/<filename>')
-# # # # # def uploaded_file(filename):
-# # # # #     return send_from_directory(UPLOAD_FOLDER, filename)
-# # # # # @app.route('/')
-# # # # # def show_latest_image():
-# # # # #     global latest_filename
-# # # # #     if not latest_filename:
-# # # # #         return "<h1>No image received yet</h1>"
-# # # # #     # Auto-refresh the page every 3 seconds
-# # # # #     html = '''
-# # # # #     <html>
-# # # # #     <head>
-# # # # #         <meta http-equiv="refresh" content="3">
-# # # # #     </head>
-# # # # #     <body>
-# # # # #         <h1>Latest Image</h1>
-# # # # #         <img src="/images/{{ file }}" style="max-width:600px;"><br>
-# # # # #         <small>{{ file }}</small>
-# # # # #     </body>
-# # # # #     </html>
-# # # # #     '''
-# # # # #     return render_template_string(html, file=latest_filename)
-# # # # # if __name__ == '__main__':
-# # # # #     app.run(host='0.0.0.0', port=7860)
-# # # # ##########################################
-# # # # from flask import Flask, request, send_from_directory, render_template_string
-# # # # import os
-# # # # from datetime import datetime
-# # # # import cv2
-# # # # import torch
-# # # # from ultralytics import YOLO
-# # # # import base64
-# # # # import numpy as np
-# # # # import google.generativeai as genai
-# # # # # Initialize Flask app
-# # # # app = Flask(__name__)
-# # # # UPLOAD_FOLDER = '/tmp/received_images'
-# # # # os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# # # # latest_filename = None
-# # # # last_extraction_result = []
-# # # # # Set your Gemini API key
-# # # # genai.configure(api_key="AIzaSyD7aLN4NphvsPuyB6N3FwVw5Nxzv7gxzv4")  # Replace for local or private space only
-# # # # gemma_model = genai.GenerativeModel(model_name="models/gemma-3-12b-it")
-# # # # def detect_and_extract_text(image_path, yolo_model_path):
-# # # #     if not os.path.exists(image_path):
-# # # #         print(f"Error: Image file not found at {image_path}")
-# # # #         return []
-# # # #     try:
-# # # #         yolo = YOLO(yolo_model_path)
-# # # #     except Exception as e:
-# # # #         print(f"Error loading YOLO model: {e}")
-# # # #         return []
-# # # #     img = cv2.imread(image_path)
-# # # #     if img is None:
-# # # #         print(f"Error: Could not load image at {image_path}")
-# # # #         return []
-# # # #     try:
-# # # #         results = yolo(image_path)
-# # # #     except Exception as e:
-# # # #         print(f"Error during YOLO inference: {e}")
-# # # #         return []
-# # # #     output = []
-# # # #     for i, r in enumerate(results):
-# # # #         for j, (box, cls) in enumerate(zip(r.boxes.xyxy, r.boxes.cls)):
-# # # #             x1, y1, x2, y2 = map(int, box)
-# # # #             cropped_img = img[y1:y2, x1:x2]
-# # # #             class_name = yolo.names[int(cls)]
-# # # #             try:
-# # # #                 cropped_img_rgb = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2RGB)
-# # # #                 _, buffer = cv2.imencode('.jpg', cropped_img_rgb)
-# # # #                 image_data = base64.b64encode(buffer).decode('utf-8')
-# # # #                 response = gemma_model.generate_content([
-# # # #                     {
-# # # #                         "role": "user",
-# # # #                         "parts": [
-# # # #                             {"text": "Extract the text from this image."},
-# # # #                             {"inline_data": {"mime_type": "image/jpeg", "data": image_data}}
-# # # #                         ]
-# # # #                     }
-# # # #                 ])
-# # # #                 extracted_text = response.text.strip()
-# # # #                 if extracted_text.lower().startswith("the text in the image is"):
-# # # #                     extracted_text = extracted_text[len("The text in the image is"):].strip().strip('"').strip("'")
-# # # #                 output.append({
-# # # #                     "class_name": class_name,
-# # # #                     "extracted_text": extracted_text
-# # # #                 })
-# # # #             except Exception as e:
-# # # #                 print(f"Error processing object {j+1} (Class={class_name}): {e}")
-# # # #                 output.append({
-# # # #                     "class_name": class_name,
-# # # #                     "extracted_text": "Error during text extraction",
-# # # #                     "bounding_box": [x1, y1, x2, y2]
-# # # #                 })
-# # # #     return output
-# # # # @app.route('/upload', methods=['POST'])
-# # # # def upload_file():
-# # # #     global latest_filename, last_extraction_result
-# # # #     img_data = request.data
-# # # #     filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpeg"
-# # # #     filepath = os.path.join(UPLOAD_FOLDER, filename)
-# # # #     with open(filepath, 'wb') as f:
-# # # #         f.write(img_data)
-# # # #     latest_filename = filename
-# # # #     # Perform detection + text extraction
-# # # #     try:
-# # # #         last_extraction_result = detect_and_extract_text(filepath, "best.pt")
-# # # #     except Exception as e:
-# # # #         last_extraction_result = [{"class_name": "Error", "extracted_text": str(e), "bounding_box": []}]
-# # # #     return 'OK', 200
-# # # # @app.route('/images/<filename>')
-# # # # def uploaded_file(filename):
-# # # #     return send_from_directory(UPLOAD_FOLDER, filename)
-# # # # @app.route('/')
-# # # # def show_latest_image():
-# # # #     global latest_filename, last_extraction_result
-# # # #     if not latest_filename:
-# # # #         return "<h1>No image received yet</h1>"
-# # # #     html = '''
-# # # #     <html>
-# # # #     <head>
-# # # #         <meta http-equiv="refresh" content="15">
-# # # #     </head>
-# # # #     <body>
-# # # #         <h1>Latest Image</h1>
-# # # #         <img src="/images/{{ file }}" style="max-width:600px;"><br>
-# # # #         <small>{{ file }}</small>
-# # # #         <h2>Extracted Information</h2>
-# # # #         <ul>
-# # # #         {% for item in result %}
-# # # #             <li><b>{{ item.class_name }}</b>: {{ item.extracted_text }} [{{ item.bounding_box }}]</li>
-# # # #         {% endfor %}
-# # # #         </ul>
-# # # #     </body>
-# # # #     </html>
-# # # #     '''
-# # # #     return render_template_string(html, file=latest_filename, result=last_extraction_result)
-# # # # if __name__ == '__main__':
-# # # #     app.run(host='0.0.0.0', port=7860)
-# # # ###########################################################################################################################################################################
-# # # from flask import Flask, request, send_from_directory, render_template_string, jsonify
-# # # import os
-# # # from datetime import datetime
-# # # import cv2
-# # # import torch
-# # # from ultralytics import YOLO
-# # # import base64
-# # # import numpy as np
-# # # import google.generativeai as genai
-# # # import json
-# # # # Initialize Flask app
-# # # app = Flask(__name__)
-# # # UPLOAD_FOLDER = '/tmp/received_images'
-# # # os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# # # latest_filename = None
-# # # last_extraction_result = []
-# # # # Set your Gemini API key
-# # # genai.configure(api_key="AIzaSyD7aLN4NphvsPuyB6N3FwVw5Nxzv7gxzv4")
-# # # gemma_model = genai.GenerativeModel(model_name="models/gemma-3-12b-it")
-# # # def prompt_engineered_extraction(base64_image):
-# # #     try:
-# # #         response = gemma_model.generate_content([
-# # #             {
-# # #                 "role": "user",
-# # #                 "parts": [
-# # #                     {"text": "Extract only the exact text from this image. Return the result as a plain JSON array of strings like [\"value1\", \"value2\"]. Do not include any explanation, label, or formatting."},
-# # #                     {"inline_data": {"mime_type": "image/jpeg", "data": base64_image}}
-# # #                 ]
-# # #             }
-# # #         ])
-# # #         extracted_text = response.text.strip()
-# # #         # Try parsing JSON result
-# # #         try:
-# # #             values = json.loads(extracted_text)
-# # #             if isinstance(values, list):
-# # #                 return ", ".join(values)
-# # #         except json.JSONDecodeError:
-# # #             # Fallback cleanup
-# # #             cleaned = extracted_text.strip('[]').split(',')
-# # #             cleaned = [v.strip().strip('"').strip("'") for v in cleaned]
-# # #             return ", ".join(cleaned)
-# # #         return extracted_text  # Fallback raw
-# # #     except Exception as e:
-# # #         print("Error in prompt-engineered extraction:", e)
-# # #         return "Error during text extraction"
-# # # def detect_and_extract_text(image_path, yolo_model_path):
-# # #     if not os.path.exists(image_path):
-# # #         print(f"Error: Image file not found at {image_path}")
-# # #         return []
-# # #     try:
-# # #         yolo = YOLO(yolo_model_path)
-# # #     except Exception as e:
-# # #         print(f"Error loading YOLO model: {e}")
-# # #         return []
-# # #     img = cv2.imread(image_path)
-# # #     if img is None:
-# # #         print(f"Error: Could not load image at {image_path}")
-# # #         return []
-# # #     try:
-# # #         results = yolo(image_path)
-# # #     except Exception as e:
-# # #         print(f"Error during YOLO inference: {e}")
-# # #         return []
-# # #     output = []
-# # #     for i, r in enumerate(results):
-# # #         for j, (box, cls) in enumerate(zip(r.boxes.xyxy, r.boxes.cls)):
-# # #             x1, y1, x2, y2 = map(int, box)
-# # #             cropped_img = img[y1:y2, x1:x2]
-# # #             class_name = yolo.names[int(cls)]
-# # #             try:
-# # #                 cropped_img_rgb = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2RGB)
-# # #                 _, buffer = cv2.imencode('.jpg', cropped_img_rgb)
-# # #                 image_data = base64.b64encode(buffer).decode('utf-8')
-# # #                 extracted = prompt_engineered_extraction(image_data)
-# # #                 output.append({
-# # #                     "class_name": class_name,
-# # #                     "extracted_text": extracted,
-# # #                     "bounding_box": [x1, y1, x2, y2]
-# # #                 })
-# # #             except Exception as e:
-# # #                 print(f"Error processing object {j+1} (Class={class_name}): {e}")
-# # #                 output.append({
-# # #                     "class_name": class_name,
-# # #                     "extracted_text": "Error during text extraction",
-# # #                     "bounding_box": [x1, y1, x2, y2]
-# # #                 })
-# # #     return output
-# # # @app.route('/upload', methods=['POST'])
-# # # def upload_file():
-# # #     global latest_filename, last_extraction_result
-# # #     img_data = request.data
-# # #     filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpeg"
-# # #     filepath = os.path.join(UPLOAD_FOLDER, filename)
-# # #     with open(filepath, 'wb') as f:
-# # #         f.write(img_data)
-# # #     latest_filename = filename
-# # #     try:
-# # #         last_extraction_result = detect_and_extract_text(filepath, "best.pt")
-# # #     except Exception as e:
-# # #         last_extraction_result = [{"class_name": "Error", "extracted_text": str(e), "bounding_box": []}]
-# # #     return 'OK', 200
-# # # @app.route('/images/<filename>')
-# # # def uploaded_file(filename):
-# # #     return send_from_directory(UPLOAD_FOLDER, filename)
-# # # @app.route('/latest')
-# # # def latest():
-# # #     return jsonify({
-# # #         "filename": latest_filename,
-# # #         "result": last_extraction_result
-# # #     })
-# # # @app.route('/')
-# # # def show_latest_image():
-# # #     html = '''
-# # #     <!DOCTYPE html>
-# # #     <html>
-# # #     <head>
-# # #         <title>Live Image Monitor</title>
-# # #         <script>
-# # #             let lastFilename = "";
-# # #             async function fetchLatest() {
-# # #                 try {
-# # #                     const response = await fetch("/latest");
-# # #                     const data = await response.json();
-# # #                     if (data.filename && data.filename !== lastFilename) {
-# # #                         document.getElementById("latest-img").src = "/images/" + data.filename + "?t=" + new Date().getTime();
-# # #                         document.getElementById("filename").innerText = data.filename;
-# # #                         let infoList = "";
-# # #                         for (const item of data.result) {
-# # #                             infoList += `<li><b>${item.class_name}</b>: ${item.extracted_text} [${item.bounding_box}]</li>`;
-# # #                         }
-# # #                         document.getElementById("info").innerHTML = infoList;
-# # #                         lastFilename = data.filename;
-# # #                     }
-# # #                 } catch (err) {
-# # #                     console.error("Error fetching latest data:", err);
-# # #                 }
-# # #             }
-# # #             setInterval(fetchLatest, 3000);
-# # #         </script>
-# # #     </head>
-# # #     <body>
-# # #         <h1>Latest Image</h1>
-# # #         <img id="latest-img" src="" style="max-width:600px;"><br>
-# # #         <small id="filename">Waiting for image...</small>
-# # #         <h2>Extracted Information</h2>
-# # #         <ul id="info"></ul>
-# # #     </body>
-# # #     </html>
-# # #     '''
-# # #     return render_template_string(html)
-# # # if __name__ == '__main__':
-# # #     app.run(host='0.0.0.0', port=7860)
-# # ########################################################################################################
-# # from flask import Flask, request, send_from_directory, render_template_string, jsonify
-# # import os
-# # from datetime import datetime
-# # import cv2
-# # import torch
-# # from ultralytics import YOLO
-# # import base64
-# # import numpy as np
-# # import google.generativeai as genai
-# # import json
-# # import time
-# # # Initialize Flask app
-# # app = Flask(__name__)
-# # UPLOAD_FOLDER = '/tmp/received_images'
-# # os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# # latest_filename = None
-# # last_extraction_result = []
-# # # Set your Gemini API key
-# # genai.configure(api_key="AIzaSyD7aLN4NphvsPuyB6N3FwVw5Nxzv7gxzv4")
-# # gemma_model = genai.GenerativeModel(model_name="models/gemma-3-12b-it")
-# # def prompt_engineered_extraction(base64_image):
-# #     try:
-# #         response = gemma_model.generate_content([
-# #             {
-# #                 "role": "user",
-# #                 "parts": [
-# #                     {"text": "Extract only the exact text from this image. Return the result as a plain JSON array of strings like [\"value1\", \"value2\"]. Do not include any explanation, label, or formatting."},
-# #                     {"inline_data": {"mime_type": "image/jpeg", "data": base64_image}}
-# #                 ]
-# #             }
-# #         ])
-# #         extracted_text = response.text.strip()
-# #         try:
-# #             values = json.loads(extracted_text)
-# #             if isinstance(values, list):
-# #                 return ", ".join(values)
-# #         except json.JSONDecodeError:
-# #             cleaned = extracted_text.strip('[]').split(',')
-# #             cleaned = [v.strip().strip('"').strip("'") for v in cleaned]
-# #             return ", ".join(cleaned)
-# #         return extracted_text
-# #     except Exception as e:
-# #         print("Error in prompt-engineered extraction:", e)
-# #         return "Error during text extraction"
-# # def detect_and_extract_text(image_path, yolo_model_path):
-# #     if not os.path.exists(image_path):
-# #         print(f"Error: Image file not found at {image_path}")
-# #         return []
-# #     try:
-# #         yolo = YOLO(yolo_model_path)
-# #     except Exception as e:
-# #         print(f"Error loading YOLO model: {e}")
-# #         return []
-# #     img = cv2.imread(image_path)
-# #     if img is None:
-# #         print(f"Error: Could not load image at {image_path}")
-# #         return []
-# #     try:
-# #         results = yolo(image_path)
-# #     except Exception as e:
-# #         print(f"Error during YOLO inference: {e}")
-# #         return []
-# #     output = []
-# #     for i, r in enumerate(results):
-# #         for j, (box, cls) in enumerate(zip(r.boxes.xyxy, r.boxes.cls)):
-# #             x1, y1, x2, y2 = map(int, box)
-# #             cropped_img = img[y1:y2, x1:x2]
-# #             class_name = yolo.names[int(cls)]
-# #             try:
-# #                 cropped_img_rgb = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2RGB)
-# #                 _, buffer = cv2.imencode('.jpg', cropped_img_rgb)
-# #                 image_data = base64.b64encode(buffer).decode('utf-8')
-# #                 extracted = prompt_engineered_extraction(image_data)
-# #                 output.append({
-# #                     "class_name": class_name,
-# #                     "extracted_text": extracted,
-# #                     "bounding_box": [x1, y1, x2, y2]
-# #                 })
-# #             except Exception as e:
-# #                 print(f"Error processing object {j+1} (Class={class_name}): {e}")
-# #                 output.append({
-# #                     "class_name": class_name,
-# #                     "extracted_text": "Error during text extraction",
-# #                     "bounding_box": [x1, y1, x2, y2]
-# #                 })
-# #     return output
-# # @app.route('/upload', methods=['POST'])
-# # def upload_file():
-# #     global latest_filename, last_extraction_result
-# #     img_data = request.data
-# #     filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpeg"
-# #     filepath = os.path.join(UPLOAD_FOLDER, filename)
-# #     with open(filepath, 'wb') as f:
-# #         f.write(img_data)
-# #     latest_filename = filename
-# #     last_extraction_result = []  # Reset before processing
-# #     try:
-# #         last_extraction_result = detect_and_extract_text(filepath, "best.pt")
-# #     except Exception as e:
-# #         last_extraction_result = [{"class_name": "Error", "extracted_text": str(e), "bounding_box": []}]
-# #     return 'OK', 200
-# # @app.route('/images/<filename>')
-# # def uploaded_file(filename):
-# #     return send_from_directory(UPLOAD_FOLDER, filename)
-# # @app.route('/latest')
-# # def latest():
-# #     global latest_filename, last_extraction_result
-# #     timeout = 10
-# #     start_time = time.time()
-# #     # Wait for extraction result to be ready
-# #     while not last_extraction_result and (time.time() - start_time) < timeout:
-# #         time.sleep(0.5)
-# #     return jsonify({
-# #         "filename": latest_filename,
-# #         "result": last_extraction_result
-# #     })
-# # @app.route('/')
-# # def show_latest_image():
-# #     html = '''
-# #     <!DOCTYPE html>
-# #     <html>
-# #     <head>
-# #         <title>Live Image Monitor</title>
-# #         <script>
-# #             let lastFilename = "";
-# #             async function fetchLatest() {
-# #                 try {
-# #                     const response = await fetch("/latest");
-# #                     const data = await response.json();
-# #                     if (data.filename && data.filename !== lastFilename && data.result && data.result.length > 0) {
-# #                         document.getElementById("latest-img").src = "/images/" + data.filename + "?t=" + new Date().getTime();
-# #                         document.getElementById("filename").innerText = data.filename;
-# #                         let infoList = "";
-# #                         for (const item of data.result) {
-# #                             infoList += `<li><b>${item.class_name}</b>: ${item.extracted_text} [${item.bounding_box}]</li>`;
-# #                         }
-# #                         document.getElementById("info").innerHTML = infoList;
-# #                         lastFilename = data.filename;
-# #                     }
-# #                 } catch (err) {
-# #                     console.error("Error fetching latest data:", err);
-# #                 }
-# #             }
-# #             setInterval(fetchLatest, 3000);
-# #         </script>
-# #     </head>
-# #     <body>
-# #         <h1>Latest Image</h1>
-# #         <img id="latest-img" src="" style="max-width:600px;"><br>
-# #         <small id="filename">Waiting for image...</small>
-# #         <h2>Extracted Information</h2>
-# #         <ul id="info"></ul>
-# #     </body>
-# #     </html>
-# #     '''
-# #     return render_template_string(html)
-# # if __name__ == '__main__':
-# #     app.run(host='0.0.0.0', port=7860)
-# ###############################################################################################################
-# from flask import Flask, request, send_from_directory, render_template_string, jsonify
-# import os
-# from datetime import datetime
-# import cv2
-# import torch
-# from ultralytics import YOLO
-# import base64
-# import numpy as np
-# import google.generativeai as genai
-# import json
-# import time
-# import requests
-# import pandas as pd
-# # Initialize Flask app
-# app = Flask(__name__)
-# UPLOAD_FOLDER = '/tmp/received_images'
-# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-# latest_filename = None
-# last_extraction_result = []
-# # Set your Gemini API key
-# genai.configure(api_key="AIzaSyD7aLN4NphvsPuyB6N3FwVw5Nxzv7gxzv4")
-# gemma_model = genai.GenerativeModel(model_name="models/gemma-3-12b-it")
-# def insert_to_supabase(values_dict):
-#     url = "https://vynkcgoqjotnhtshbrdf.supabase.co/rest/v1/vitals"
-#     headers = {
-#         "apikey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZ5bmtjZ29xam90bmh0c2hicmRmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTAxMzEwMzEsImV4cCI6MjA2NTcwNzAzMX0.TEC0I2WtCMcUTt6xo5RYIHUuiOcfsJLIiYdFuUVXZI4",
-#         "Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZ5bmtjZ29xam90bmh0c2hicmRmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTAxMzEwMzEsImV4cCI6MjA2NTcwNzAzMX0.TEC0I2WtCMcUTt6xo5RYIHUuiOcfsJLIiYdFuUVXZI4",
-#         "Content-Type": "application/json"
-#     }
-#     try:
-#         response = requests.post(url, headers=headers, json=values_dict)
-#         if response.status_code == 201:
-#             print("✅ Successfully inserted to Supabase.")
-#         else:
-#             print("❌ Failed to insert to Supabase.")
-#             print("Status code:", response.status_code)
-#             print("Response:", response.text)
-#     except Exception as e:
-#         print("❌ Error sending data to Supabase:", e)
-# def prompt_engineered_extraction(base64_image):
-#     try:
-#         response = gemma_model.generate_content([
-#             {
-#                 "role": "user",
-#                 "parts": [
-#                     {"text": "Extract only the exact text from this image. Return the result as a plain JSON array of strings like [\"value1\", \"value2\"]. Do not include any explanation, label, or formatting."},
-#                     {"inline_data": {"mime_type": "image/jpeg", "data": base64_image}}
-#                 ]
-#             }
-#         ])
-#         extracted_text = response.text.strip()
-#         try:
-#             values = json.loads(extracted_text)
-#             if isinstance(values, list):
-#                 return ", ".join(values)
-#         except json.JSONDecodeError:
-#             cleaned = extracted_text.strip('[]').split(',')
-#             cleaned = [v.strip().strip('"').strip("'") for v in cleaned]
-#             return ", ".join(cleaned)
-#         return extracted_text
-#     except Exception as e:
-#         print("Error in prompt-engineered extraction:", e)
-#         return "Error during text extraction"
-# def detect_and_extract_text(image_path, yolo_model_path):
-#     if not os.path.exists(image_path):
-#         print(f"❌ Error: Image file not found at {image_path}")
-#         return []
-#     try:
-#         yolo = YOLO(yolo_model_path)
-#     except Exception as e:
-#         print(f"❌ Error loading YOLO model: {e}")
-#         return []
-#     img = cv2.imread(image_path)
-#     if img is None:
-#         print(f"❌ Error: Could not load image at {image_path}")
-#         return []
-#     try:
-#         results = yolo(image_path)
-#     except Exception as e:
-#         print(f"❌ Error during YOLO inference: {e}")
-#         return []
-#     output = []
-#     vitals_dict = {}  # To collect values for Supabase
-#     for i, r in enumerate(results):
-#         for j, (box, cls) in enumerate(zip(r.boxes.xyxy, r.boxes.cls)):
-#             x1, y1, x2, y2 = map(int, box)
-#             cropped_img = img[y1:y2, x1:x2]
-#             class_name = yolo.names[int(cls)].lower()
-#             try:
-#                 cropped_img_rgb = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2RGB)
-#                 _, buffer = cv2.imencode('.jpg', cropped_img_rgb)
-#                 image_data = base64.b64encode(buffer).decode('utf-8')
-#                 extracted = prompt_engineered_extraction(image_data)
-#                 # Parse and store valid vitals
-#                 try:
-#                     if class_name == "heart rate":
-#                         vitals_dict["heart_rate"] = int(extracted)
-#                     elif class_name == "respiratory rate":
-#                         vitals_dict["respiratory_rate"] = int(extracted)
-#                     elif class_name == "oxygen saturation":
-#                         vitals_dict["oxygen_saturation"] = int(extracted)
-#                     elif class_name == "blood pressure":
-#                         if "/" in extracted:
-#                             vitals_dict["blood_pressure"] = extracted  # keep as string
-#                 except Exception as ve:
-#                     print(f"⚠️ Could not parse {class_name}: {extracted} — {ve}")
-#                 output.append({
-#                     "class_name": class_name,
-#                     "extracted_text": extracted,
-#                     "bounding_box": [x1, y1, x2, y2]
-#                 })
-#             except Exception as e:
-#                 print(f"❌ Error processing object {j+1} (Class={class_name}): {e}")
-#                 output.append({
-#                     "class_name": class_name,
-#                     "extracted_text": "Error during text extraction",
-#                     "bounding_box": [x1, y1, x2, y2]
-#                 })
-#     # ✅ Insert to Supabase if we have at least 1 valid value
-#     if vitals_dict:
-#         insert_to_supabase(vitals_dict)
-#     return output
-# @app.route('/dashboard')
-# def dashboard():
-#     html = '''
-#     <!DOCTYPE html>
-#     <html>
-#     <head>
-#         <title>Vitals Dashboard</title>
-#         <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
-#     </head>
-#     <body>
-#         <h1>Vitals Dashboard</h1>
-#         <div id="chart" style="width:100%;height:600px;"></div>
-#         <script>
-#             async function loadData() {
-#                 const res = await fetch("/vitals_data");
-#                 const data = await res.json();
-#                 if (data.error) {
-#                     document.getElementById("chart").innerText = "Error: " + data.details;
-#                     return;
-#                 }
-#                 const timestamps = [];
-#                 const heartRate = [];
-#                 const respiratoryRate = [];
-#                 const oxygen = [];
-#                 const systolicBP = [];
-#                 const diastolicBP = [];
-#                 for (const item of data) {
-#                     timestamps.push(item.timestamp);
-#                     heartRate.push(item.heart_rate);
-#                     respiratoryRate.push(item.respiratory_rate);
-#                     oxygen.push(item.oxygen_saturation);
-#                     if (item.blood_pressure && item.blood_pressure.includes('/')) {
-#                         const [sys, dia] = item.blood_pressure.split('/');
-#                         systolicBP.push(parseInt(sys));
-#                         diastolicBP.push(parseInt(dia));
-#                     } else {
-#                         systolicBP.push(null);
-#                         diastolicBP.push(null);
-#                     }
-#                 }
-#                 const layout = {
-#                     title: "Vitals over Time",
-#                     xaxis: { title: "Timestamp" },
-#                     yaxis: { title: "Values" }
-#                 };
-#                 const traces = [
-#                     {
-#                         x: timestamps,
-#                         y: heartRate,
-#                         name: "Heart Rate",
-#                         type: "scatter"
-#                     },
-#                     {
-#                         x: timestamps,
-#                         y: respiratoryRate,
-#                         name: "Respiratory Rate",
-#                         type: "scatter"
-#                     },
-#                     {
-#                         x: timestamps,
-#                         y: oxygen,
-#                         name: "Oxygen Saturation",
-#                         type: "scatter"
-#                     },
-#                     {
-#                         x: timestamps,
-#                         y: systolicBP,
-#                         name: "Systolic BP",
-#                         type: "scatter"
-#                     },
-#                     {
-#                         x: timestamps,
-#                         y: diastolicBP,
-#                         name: "Diastolic BP",
-#                         type: "scatter"
-#                     }
-#                 ];
-#                 Plotly.newPlot("chart", traces, layout);
-#             }
-#             loadData();
-#         </script>
-#     </body>
-#     </html>
-#     '''
-#     return render_template_string(html)
-# @app.route('/vitals_data')
-# def vitals_data():
-#     supabase_url = "https://vynkcgoqjotnhtshbrdf.supabase.co/rest/v1/vitals"
-#     api_key = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZ5bmtjZ29xam90bmh0c2hicmRmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTAxMzEwMzEsImV4cCI6MjA2NTcwNzAzMX0.TEC0I2WtCMcUTt6xo5RYIHUuiOcfsJLIiYdFuUVXZI4"  # replace with your actual key
-#     headers = {
-#         "apikey": api_key,
-#         "Authorization": f"Bearer {api_key}"
-#     }
-#     response = requests.get(supabase_url, headers=headers)
-#     if response.status_code == 200:
-#         return jsonify(response.json())
-#     else:
-#         return jsonify({"error": "Failed to fetch data", "details": response.text}), 500
-# @app.route('/upload', methods=['POST'])
-# def upload_file():
-#     global latest_filename, last_extraction_result
-#     img_data = request.data
-#     filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpeg"
-#     filepath = os.path.join(UPLOAD_FOLDER, filename)
-#     with open(filepath, 'wb') as f:
-#         f.write(img_data)
-#     latest_filename = filename
-#     last_extraction_result = []  # Reset before processing
-#     try:
-#         last_extraction_result = detect_and_extract_text(filepath, "best.pt")
-#     except Exception as e:
-#         last_extraction_result = [{"class_name": "Error", "extracted_text": str(e), "bounding_box": []}]
-#     return 'OK', 200
-# @app.route('/images/<filename>')
-# def uploaded_file(filename):
-#     return send_from_directory(UPLOAD_FOLDER, filename)
-# @app.route('/latest')
-# def latest():
-#     global latest_filename, last_extraction_result
-#     timeout = 10
-#     start_time = time.time()
-#     # Wait for extraction result to be ready
-#     while not last_extraction_result and (time.time() - start_time) < timeout:
-#         time.sleep(0.5)
-#     return jsonify({
-#         "filename": latest_filename,
-#         "result": last_extraction_result
-#     })
-# @app.route('/')
-# def show_latest_image():
-#     html = '''
-#     <!DOCTYPE html>
-#     <html>
-#     <head>
-#         <title>Live Image Monitor</title>
-#         <script>
-#             let lastFilename = "";
-#             async function fetchLatest() {
-#                 try {
-#                     const response = await fetch("/latest");
-#                     const data = await response.json();
-#                     if (data.filename && data.filename !== lastFilename && data.result && data.result.length > 0) {
-#                         document.getElementById("latest-img").src = "/images/" + data.filename + "?t=" + new Date().getTime();
-#                         document.getElementById("filename").innerText = data.filename;
-#                         let infoList = "";
-#                         for (const item of data.result) {
-#                             infoList += `<li><b>${item.class_name}</b>: ${item.extracted_text} [${item.bounding_box}]</li>`;
-#                         }
-#                         document.getElementById("info").innerHTML = infoList;
-#                         lastFilename = data.filename;
-#                     }
-#                 } catch (err) {
-#                     console.error("Error fetching latest data:", err);
-#                 }
-#             }
-#             setInterval(fetchLatest, 3000);
-#         </script>
-#     </head>
-#     <body>
-#         <h1>Latest Image</h1>
-#         <img id="latest-img" src="" style="max-width:600px;"><br>
-#         <small id="filename">Waiting for image...</small>
-#         <h2>Extracted Information</h2>
-#         <ul id="info"></ul>
-#     </body>
-#     </html>
-#     '''
-#     return render_template_string(html)
-# if __name__ == '__main__':
-#     app.run(host='0.0.0.0', port=7860)
-######################################################################################################################

     response = requests.get(url, headers=headers, params=params)
     return jsonify(response.json()) if response.status_code == 200 else jsonify({"error": response.text}), 500
 @app.route('/dashboard')
 def dashboard():
 if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)