Spaces:

tejovk311
/

esp_server

Sleeping

App Files Files Community

tejovk311 commited on Jun 17, 2025

Commit

b5d6210

verified ·

1 Parent(s): 8d58e29

Update app.py

Browse files

Files changed (1) hide show

app.py +308 -302

app.py CHANGED Viewed

@@ -1,22 +1,159 @@
 # # # # 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>')
@@ -25,33 +162,43 @@
 # # # # @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
@@ -60,6 +207,7 @@
 # # # import base64
 # # # import numpy as np
 # # # import google.generativeai as genai
 # # # # Initialize Flask app
 # # # app = Flask(__name__)
@@ -71,9 +219,39 @@
 # # # 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}")
@@ -109,23 +287,12 @@
 # # #                 _, 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:
@@ -148,7 +315,6 @@
 # # #         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:
@@ -160,44 +326,71 @@
 # # # 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
@@ -208,6 +401,7 @@
 # # import numpy as np
 # # import google.generativeai as genai
 # # import json
 # # # Initialize Flask app
 # # app = Flask(__name__)
@@ -235,18 +429,16 @@
 # #         ])
 # #         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)
@@ -314,6 +506,7 @@
 # #     with open(filepath, 'wb') as f:
 # #         f.write(img_data)
 # #     latest_filename = filename
 # #     try:
 # #         last_extraction_result = detect_and_extract_text(filepath, "best.pt")
@@ -328,6 +521,15 @@
 # # @app.route('/latest')
 # # def latest():
 # #     return jsonify({
 # #         "filename": latest_filename,
 # #         "result": last_extraction_result
@@ -347,7 +549,8 @@
 # #                 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;
@@ -388,7 +591,11 @@
-# ########################################################################################################
 # from flask import Flask, request, send_from_directory, render_template_string, jsonify
@@ -402,6 +609,7 @@
 # import google.generativeai as genai
 # import json
 # import time
 # # Initialize Flask app
 # app = Flask(__name__)
@@ -416,6 +624,49 @@
 # 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([
@@ -481,6 +732,16 @@
 #                 extracted = prompt_engineered_extraction(image_data)
 #                 output.append({
 #                     "class_name": class_name,
 #                     "extracted_text": extracted,
@@ -544,29 +805,24 @@
 #         <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>
@@ -586,256 +842,6 @@
-###############################################################################################################
-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
-# 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")
-# Supabase configuration
-SUPABASE_URL = "https://vynkcgoqjotnhtshbrdf.supabase.co"
-SUPABASE_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZ5bmtjZ29xam90bmh0c2hicmRmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTAxMzEwMzEsImV4cCI6MjA2NTcwNzAzMX0.TEC0I2WtCMcUTt6xo5RYIHUuiOcfsJLIiYdFuUVXZI4"
-def store_to_supabase(values_dict):
-    headers = {
-        "apikey": SUPABASE_API_KEY,
-        "Authorization": f"Bearer {SUPABASE_API_KEY}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "heart_rate": None,
-        "blood_pressure": None,
-        "respiratory_rate": None,
-        "oxygen_saturation": None
-    }
-    for key in payload.keys():
-        if key in values_dict:
-            val = values_dict[key]
-            if key == "blood_pressure":
-                if '/' in val and all(part.strip().isdigit() for part in val.split('/')):
-                    payload[key] = val.strip()
-            else:
-                if val.strip().isdigit():
-                    payload[key] = int(val.strip())
-    for key in payload:
-        if payload[key] is None:
-            payload[key] = None
-    try:
-        response = requests.post(
-            f"{SUPABASE_URL}/rest/v1/vitals",
-            headers=headers,
-            json=payload
-        )
-        response.raise_for_status()
-        print("✅ Data stored in Supabase:", payload)
-    except Exception as e:
-        print("❌ Error storing 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 = []
-    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)
-                # Try storing to Supabase if it's a known vital
-                vitals_key_map = {
-                    "heart_rate": "heart_rate",
-                    "blood_pressure": "blood_pressure",
-                    "respiratory_rate": "respiratory_rate",
-                    "oxygen_saturation": "oxygen_saturation"
-                }
-                if class_name in vitals_key_map:
-                    store_to_supabase({vitals_key_map[class_name]: extracted})
-                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
+# # # # # 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>')
 # # # # @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 base64
 # # # import numpy as np
 # # # import google.generativeai as genai
+# # # import json
 # # # # Initialize Flask app
 # # # app = Flask(__name__)
 # # # 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}")
 # # #                 _, 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:
 # # #         f.write(img_data)
 # # #     latest_filename = filename
 # # #     try:
 # # #         last_extraction_result = detect_and_extract_text(filepath, "best.pt")
 # # #     except Exception as e:
 # # # 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 numpy as np
 # # import google.generativeai as genai
 # # import json
+# # import time
 # # # Initialize Flask app
 # # app = Flask(__name__)
 # #         ])
 # #         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)
 # #     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")
 # # @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
 # #                 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;
+# ###############################################################################################################
 # from flask import Flask, request, send_from_directory, render_template_string, jsonify
 # import google.generativeai as genai
 # import json
 # import time
+# import requests
 # # Initialize Flask app
 # app = Flask(__name__)
 # genai.configure(api_key="AIzaSyD7aLN4NphvsPuyB6N3FwVw5Nxzv7gxzv4")
 # gemma_model = genai.GenerativeModel(model_name="models/gemma-3-12b-it")
+# # Supabase configuration
+# SUPABASE_URL = "https://vynkcgoqjotnhtshbrdf.supabase.co"
+# SUPABASE_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZ5bmtjZ29xam90bmh0c2hicmRmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTAxMzEwMzEsImV4cCI6MjA2NTcwNzAzMX0.TEC0I2WtCMcUTt6xo5RYIHUuiOcfsJLIiYdFuUVXZI4"
+# def store_to_supabase(values_dict):
+#     headers = {
+#         "apikey": SUPABASE_API_KEY,
+#         "Authorization": f"Bearer {SUPABASE_API_KEY}",
+#         "Content-Type": "application/json"
+#     }
+#     payload = {
+#         "heart_rate": None,
+#         "blood_pressure": None,
+#         "respiratory_rate": None,
+#         "oxygen_saturation": None
+#     }
+#     for key in payload.keys():
+#         if key in values_dict:
+#             val = values_dict[key]
+#             if key == "blood_pressure":
+#                 if '/' in val and all(part.strip().isdigit() for part in val.split('/')):
+#                     payload[key] = val.strip()
+#             else:
+#                 if val.strip().isdigit():
+#                     payload[key] = int(val.strip())
+#     for key in payload:
+#         if payload[key] is None:
+#             payload[key] = None
+#     try:
+#         response = requests.post(
+#             f"{SUPABASE_URL}/rest/v1/vitals",
+#             headers=headers,
+#             json=payload
+#         )
+#         response.raise_for_status()
+#         print("✅ Data stored in Supabase:", payload)
+#     except Exception as e:
+#         print("❌ Error storing to Supabase:", e)
 # def prompt_engineered_extraction(base64_image):
 #     try:
 #         response = gemma_model.generate_content([
 #                 extracted = prompt_engineered_extraction(image_data)
+#                 # Try storing to Supabase if it's a known vital
+#                 vitals_key_map = {
+#                     "heart_rate": "heart_rate",
+#                     "blood_pressure": "blood_pressure",
+#                     "respiratory_rate": "respiratory_rate",
+#                     "oxygen_saturation": "oxygen_saturation"
+#                 }
+#                 if class_name in vitals_key_map:
+#                     store_to_supabase({vitals_key_map[class_name]: extracted})
 #                 output.append({
 #                     "class_name": class_name,
 #                     "extracted_text": extracted,
 #         <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>
 import requests
+response = requests.get("https://vynkcgoqjotnhtshbrdf.supabase.co")
+print(response.status_code)