Spaces:

tejovk311
/

esp_server

Sleeping

App Files Files Community

tejovk311 commited on Jun 17, 2025

Commit

8d58e29

verified ·

1 Parent(s): 53f075d

Update app.py

Browse files

Files changed (1) hide show

app.py +306 -50

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 numpy as np
 import google.generativeai as genai
 import json
 import time
 # Initialize Flask app
 app = Flask(__name__)
@@ -416,6 +624,49 @@ last_extraction_result = []
 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 @@ def detect_and_extract_text(image_path, yolo_model_path):
                 extracted = prompt_engineered_extraction(image_data)
                 output.append({
                     "class_name": class_name,
                     "extracted_text": extracted,
@@ -544,29 +805,24 @@ def show_latest_image():
         <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>

+# # # # 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>