R eupload changes

app.py

@@ -1,3 +1,4 @@
+from hmac import trans_36
 import gradio as gr
 from util import css, js, Color
 import pandas as pd
@@ -7,6 +8,7 @@ from accounts import Account
 from database import read_log
 import threading
 from trading_floor import run_every_n_minutes
+from util import stop_event
 import asyncio
 import os
 
@@ -20,6 +22,8 @@ mapper = {
 }
 
 
+trading_thread = None
+
 class Trader:
     def __init__(self, name: str, lastname: str, model_name: str):
         self.name = name
@@ -180,20 +184,52 @@ def setup_directories():
             print(f"Error creating directory {MEMORY_DIR}: {e}")
             raise
 
-def start_trading_floor():
-    """Run trading floor in a separate thread"""
-    # 1. Ensure the directory is ready
-    setup_directories() 
-    # 2. Proceed with running the agents
-    asyncio.run(run_every_n_minutes())
+def stop_trading_thread():
+    global trading_thread
+
+    if trading_thread is None or not trading_thread.is_alive():
+        return "🛑 Trading floor is not running."
+
+    print("Stopping trading floor...")
+    
+    # 1. Set the stop signal
+    stop_event.set()
+    
+    # 2. Wait for the thread to finish its current task and exit the loop safely
+    trading_thread.join(timeout=10) # Wait up to 10 seconds for graceful exit
+    
+    if trading_thread.is_alive():
+        return "❌ Trading floor thread failed to stop gracefully within 10 seconds."
+    else:
+        trading_thread = None # Clear the variable
+        return "✅ Trading floor stopped successfully."
+
+def start_trading_floor_and_thread():
+    global trading_thread
+
+    # check is thead is running
+    if trading_thread is not None and trading_thread.is_alive():
+        return "⚠️ Trading floor is already running."
+
+    # Reset the stop event and create directory
+    stop_event.clear()
+    setup_directories()
+
+    # 3. Define the thread's target function (wrapper to pass the event)
+    def target_wrapper():
+        # The target function now correctly passes the stop_event
+        asyncio.run(run_every_n_minutes())
+
+    # 4. Create and start the thread
+    trading_thread = threading.Thread(target=target_wrapper, daemon=True)
+    trading_thread.start()
+    return "🚀 Trading floor started."
 
-# Start trading floor in background thread
-trading_thread = threading.Thread(target=start_trading_floor, daemon=True)
-trading_thread.start()
 
 # Main UI construction
 def create_ui():
     """Create the main Gradio UI for the trading simulation"""
+    print(f"Stop event {stop_event.is_set()}")
 
     traders = [
         Trader(trader_name, lastname, model_name)
@@ -201,9 +237,33 @@ def create_ui():
     ]
     trader_views = [TraderView(trader) for trader in traders]
 
+    # stop_btn = gr.Button("Stop Trading Floor", variant="stop")
+    # stop_btn.click(fn=lambda: stop_trading_floor(), inputs=[], outputs=[])
+
     with gr.Blocks(
         title="Traders", css=css, js=js, theme=gr.themes.Default(primary_hue="sky"), fill_width=True
     ) as ui:
+
+        with gr.Row():
+            start_btn = gr.Button("Start Trading Floor 🚀", variant="primary")
+            stop_btn = gr.Button("Stop Trading Floor 🛑", variant="stop")
+
+        # Add Status Output
+        thread_status = gr.Textbox(label="Thread Status", value="Ready to start.", interactive=False)
+
+        # Link buttons to functions
+        start_btn.click(
+            fn=start_trading_floor_and_thread, 
+            outputs=[thread_status], 
+            show_progress="hidden"
+        )
+        
+        stop_btn.click(
+            fn=stop_trading_thread, 
+            outputs=[thread_status], 
+            show_progress="hidden"
+        )
+
         with gr.Row():
             for trader_view in trader_views:
                 trader_view.make_ui()

trading_floor.py

@@ -1,3 +1,4 @@
+import threading
 from traders import Trader
 from typing import List
 import asyncio
@@ -5,6 +6,7 @@ from tracers import LogTracer
 from agents import add_trace_processor
 from market import is_market_open
 from dotenv import load_dotenv
+from util import stop_event
 import os
 
 load_dotenv(override=True)
@@ -39,14 +41,49 @@ def create_traders() -> List[Trader]:
 
 
 async def run_every_n_minutes():
+    """
+    Runs trading agents every N minutes, cooperatively stopping when signaled.
+    """
     add_trace_processor(LogTracer())
     traders = create_traders()
-    while True:
+    
+    # Create an asyncio Event to link the thread signal to the loop
+    async_stop_event = asyncio.Event()
+
+    # Function to set the asyncio event from the thread's loop
+    def stop_callback():
+        # This function runs in the context of the running asyncio loop
+        if stop_event.is_set():
+            async_stop_event.set()
+        else:
+            # Re-schedule this check if the event hasn't been set
+            loop = asyncio.get_running_loop()
+            loop.call_later(1, stop_callback)
+
+    # Start the periodic check for the threading.Event
+    loop = asyncio.get_running_loop()
+    loop.call_later(1, stop_callback)
+
+    while not async_stop_event.is_set():
         if RUN_EVEN_WHEN_MARKET_IS_CLOSED or is_market_open():
+            print("Running trade cycle...")
+            # Run agents
             await asyncio.gather(*[trader.run() for trader in traders])
         else:
             print("Market is closed, skipping run")
-        await asyncio.sleep(RUN_EVERY_N_MINUTES * 60)
+
+        # Wait for the next interval OR the stop signal
+        try:
+            # Wait for the interval, but be interruptible by async_stop_event.set()
+            await asyncio.wait_for(async_stop_event.wait(), timeout=RUN_EVERY_N_MINUTES * 60)
+        except asyncio.TimeoutError:
+            # Timeout hit, continue to the next iteration
+            continue
+        except Exception:
+            # The async_stop_event was set, or another issue occurred
+            break
+        
+    print("Agent trading loop terminated safely.")
 
 
 if __name__ == "__main__":

util.py

@@ -1,5 +1,9 @@
 from enum import Enum
 
+import threading
+
+stop_event = threading.Event()
+
 css = """
 .positive-pnl {
     color: green !important;