Update app.py

app.py

@@ -11,9 +11,6 @@ import uuid
 from openai import OpenAI
 import os
 from dotenv import load_dotenv 
-import requests
-import queue
-import threading
 
 load_dotenv() 
 
@@ -139,8 +136,6 @@ ACTION_COLS = [
     'Decreasing Pressure', 'Acceleration', 'Decelerating'
 ]
 
-api_results_queue = queue.Queue()
-
 recording = False
 recording_thread = None
 
@@ -155,60 +150,14 @@ def parse_time_str(tstr):
     return m * 60 + s
 
 def send_to_api(file_path, start_sec, end_sec, actions):
-    """Send video file to API for prediction"""
     print(f"📤 Sending {file_path} to API...")
     print(f"⏱ Clip time: {start_sec}-{end_sec} sec")
-    #print(f"📝 Actions in this clip: {actions}")
-    
-    # Fix URL format - add http:// protocol
-    url = "http://172.16.30.129:8000/predict"
-    
-    try:
-        # Prepare the file and timestamp
-        with open(file_path, 'rb') as file:
-            files = {'file': file}
-            
-            # Convert start_sec to timestamp format expected by server
-            # Assuming timestamp should be in "MM:SS" format or seconds
-            timestamp = str(int(start_sec))  # or format_time(start_sec) if MM:SS format needed
-            
-            data = {'timestamp': timestamp}
-            
-            # Make the POST request
-            response = requests.post(url, files=files, data=data, timeout=30)
-            
-            if response.status_code == 200:
-                result = response.json()
-                print("✅ API Response:")
-                print(f"   Timestamp: {result['timestamp']}")
-                print(f"   Predicted Actions: {result['actions']}")
-                # print(f"   Probabilities: {result['probabilities']}")
-                return result
-            else:
-                print(f"❌ API Error: {response.status_code}")
-                print(f"   Error message: {response.text}")
-                return None
-                
-    except requests.exceptions.ConnectionError:
-        print("❌ Connection Error: Could not connect to the API server")
-        return None
-    except requests.exceptions.Timeout:
-        print("❌ Timeout Error: Request took too long")
-        return None
-    except requests.exceptions.RequestException as e:
-        print(f"❌ Request Error: {e}")
-        return None
-    except FileNotFoundError:
-        print(f"❌ File Error: Could not find file {file_path}")
-        return None
-    except Exception as e:
-        print(f"❌ Unexpected Error: {e}")
-        return None
+    print(f"📝 Actions in this clip: {actions}")
 
-def record_video(actions_state_snapshot, is_recording, recording_start_time):
-    global recording, api_results_queue
+def record_video(actions_state, is_recording, recording_start_time):
+    global recording
     cap = cv2.VideoCapture(0)
-    fps = 30
+    fps = int(cap.get(cv2.CAP_PROP_FPS) or 24)
     width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
@@ -231,62 +180,17 @@ def record_video(actions_state_snapshot, is_recording, recording_start_time):
         clip_idx += 1
 
         actions_in_clip = []
-        for item in actions_state_snapshot:
+        for item in actions_state:
             t_sec = parse_time_str(item["timestamp"])
             if elapsed_start <= t_sec < elapsed_end:
                 actions_in_clip.extend(item["actions"])
         actions_in_clip = list(set(actions_in_clip))
 
         if recording:
-            result = send_to_api(filename, elapsed_start, elapsed_end, actions_in_clip)
-            # Put result in queue instead of directly modifying state
-            new_item = {
-                "id": str(uuid.uuid4()),
-                "timestamp": format_time(elapsed_start),
-                "actions": actions_in_clip,
-                "result": result
-            }
-            api_results_queue.put(new_item)
+            send_to_api(filename, elapsed_start, elapsed_end, actions_in_clip)
 
     cap.release()
 
-def extract_actions_from_api_result(api_result):
-    """Extract action names from API result based on the PredictionResponse structure"""
-    if not api_result or 'actions' not in api_result:
-        return []
-    
-    # api_result['actions'] is a Dict[str, int] where 1 means the action is detected
-    detected_actions = []
-    for action_name, is_detected in api_result['actions'].items():
-        if is_detected == 1:
-            detected_actions.append(action_name)
-    
-    return detected_actions
-
-def check_api_results(actions_state):
-    """Check for new API results and update the state"""
-    global api_results_queue
-    updated = False
-    
-    while not api_results_queue.empty():
-        try:
-            new_item = api_results_queue.get_nowait()
-            # Extract the actual detected actions from the API result
-            if new_item.get('result'):
-                detected_actions = extract_actions_from_api_result(new_item['result'])
-                new_item['actions'] = detected_actions
-            
-            actions_state.append(new_item)
-            updated = True
-            print(f"✅ Added API result to table: {new_item['timestamp']} - Actions: {new_item['actions']}")
-        except queue.Empty:
-            break
-    
-    if updated:
-        return actions_state, render_table(actions_state, None)
-    else:
-        return actions_state, gr.update()
-
 def toggle_recording(state, is_recording, recording_start_time, actions_state, accept_visible):
     global recording, recording_thread
     if state == "Start":
@@ -331,23 +235,19 @@ def render_table(actions_state, edit_index):
         wrap=True
     )
 
-def start_edit(idx, actions_state):
+def start_edit(idx, actions_state, new_actions=None):
     try:
         idx = int(idx)
         if 0 <= idx < len(actions_state):
-            return idx, actions_state[idx]["actions"]
+            # ถ้ามี new_actions ให้บันทึกเลย
+            if new_actions is not None:
+                actions_state[idx]["actions"] = new_actions
+            return idx, actions_state[idx]["actions"], actions_state
         else:
-            return None, []
+            return None, [], actions_state
     except Exception:
-        return None, []
-
-def save_edit(idx, new_actions, actions_state):
-    if idx is not None and 0 <= idx < len(actions_state):
-        actions_state[idx]["actions"] = new_actions
-    return None, None, actions_state
+        return None, [], actions_state
 
-def cancel_edit():
-    return None, None
 
 def clean_markdown_response(response_text):
     """Clean markdown code block markers from LLM response"""
@@ -393,7 +293,7 @@ def LLM_Summarize(actions_state):
         
 
         response = client.chat.completions.create(
-            model="gpt-4o-mini",  # Updated to use GPT-4o mini
+            model="typhoon-v2.1-12b-instruct",  # Updated to use Typhoon model
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": f"Here is the CSV data to analyze:\n\n{csv_data}"}
@@ -633,40 +533,25 @@ def main():
 
         # Edit functionality
         with gr.Row():
-            edit_row = gr.Number(label="📝 Edit Row (0-based)", precision=0)
-            edit_multiselect = gr.CheckboxGroup(choices=ACTION_COLS, label="แก้ไข Actions")
-            save_btn = gr.Button("💾 Save Edit")
-            cancel_btn = gr.Button("❌ Cancel Edit")
+             edit_row = gr.Number(label="📝 Edit Row (0-based)", precision=0)
+             edit_multiselect = gr.CheckboxGroup(choices=ACTION_COLS, label="แก้ไข Actions")
 
         edit_row.change(
-            start_edit,
+            lambda idx, actions_state: start_edit(idx, actions_state),
             inputs=[edit_row, actions_state],
-            outputs=[edit_index, edit_multiselect]
+            outputs=[edit_index, edit_multiselect, actions_state]
         )
 
-        save_btn.click(
-            save_edit,
-            inputs=[edit_index, edit_multiselect, actions_state],
+        # เมื่อแก้ไข multiselect ให้บันทึกอัตโนมัติ
+        edit_multiselect.change(
+            lambda new_actions, edit_index, actions_state: start_edit(edit_index, actions_state, new_actions),
+            inputs=[edit_multiselect, edit_index, actions_state],
             outputs=[edit_index, edit_multiselect, actions_state]
         ).then(
             render_table,
             inputs=[actions_state, edit_index],
             outputs=actions_table
-        )
-
-        cancel_btn.click(
-            cancel_edit,
-            outputs=[edit_index, edit_multiselect]
-        )
-
-        api_check_timer = gr.Timer(value=0.5)  # Check every 0.5 seconds
-    
-        api_check_timer.tick(
-            check_api_results,
-            inputs=[actions_state],
-            outputs=[actions_state, actions_table]
-        )
-
+    )
     demo.launch()
 
 if __name__ == "__main__":