Create app.py

app.py

@@ -0,0 +1,469 @@
+import gradio as gr
+import numpy as np
+import json
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+class TradeArenaEnv_Deterministic:
+    """
+    Odyssey Arena - AI Trading Environment (Deterministic version)
+    """
+    def __init__(self, cfg):
+        self.num_days = cfg["num_days"]
+        self.stocks = cfg["stocks"]
+        self.variables = cfg["variables"]
+        self.dependency_matrix = np.array(cfg["dependency_matrix"])
+        self.initial_prices = np.array(cfg["initial_prices"])
+        self.initial_variables = np.array(cfg["initial_variables"])
+        self.timeline = cfg["timeline"]
+        self.price_noise_scale = cfg.get("price_noise_scale", 0.0)
+        self.initial_cash = cfg.get("initial_cash", 10000.0)
+        self.reset()
+
+    def reset(self):
+        self.t = 0
+        self.cash = self.initial_cash
+        self.positions = np.zeros(len(self.stocks))
+        self.prices = self.initial_prices.copy()
+        self.variables_state = self.initial_variables.copy()
+        self.next_day_news = self.timeline.get("day_1", None)
+        return self._get_observation()
+
+    def _get_observation(self):
+        obs = {
+            "day": self.t,
+            "prices": {s: float(p) for s, p in zip(self.stocks, self.prices)},
+            "cash": float(self.cash),
+            "positions": {s: int(pos) for s, pos in zip(self.stocks, self.positions)},
+            "total_value": float(self.cash + np.sum(self.positions * self.prices)),
+            "news_next_day": self.next_day_news["variable_changes"] if self.next_day_news else None,
+            "news_next_day_text": self.next_day_news["news_text"] if self.next_day_news else None
+        }
+        return obs
+
+    def step(self, action):
+        assert isinstance(action, dict)
+        
+        # Execute sells first
+        for stock, qty in action.get("sell", {}).items():
+            idx = self.stocks.index(stock)
+            qty = int(qty)
+            qty = min(qty, self.positions[idx])
+            revenue = self.prices[idx] * qty
+            self.positions[idx] -= qty
+            self.cash += revenue
+
+        # Then buys
+        for stock, qty in action.get("buy", {}).items():
+            idx = self.stocks.index(stock)
+            qty = int(qty)
+            cost = self.prices[idx] * qty
+            if cost <= self.cash:
+                self.positions[idx] += qty
+                self.cash -= cost
+
+        # Advance one day
+        self.t += 1
+        done = self.t >= self.num_days
+
+        # Update variable states & prices
+        if not done:
+            news_today = self.timeline.get(f"day_{self.t}", None)
+            if news_today:
+                deltas = np.array(news_today["variable_changes"])
+                self.variables_state += deltas
+                self._update_prices_from_variables(deltas)
+
+        # Prepare next day's news
+        self.next_day_news = self.timeline.get(f"day_{self.t + 1}", None) if not done else None
+
+        reward = self._compute_reward()
+        obs = self._get_observation()
+        return obs, reward, done, {}
+
+    def _update_prices_from_variables(self, delta_vars):
+        delta_price = self.dependency_matrix @ delta_vars
+        noise = np.zeros_like(delta_price) if self.price_noise_scale == 0 else np.random.normal(
+            0, self.price_noise_scale, len(self.stocks)
+        )
+        self.prices += delta_price + noise
+        self.prices = np.clip(self.prices, 0.1, None)
+
+    def _compute_reward(self):
+        total_value = self.cash + np.sum(self.positions * self.prices)
+        return round(float(total_value), 2)
+
+
+# Default configuration
+DEFAULT_CONFIG = {
+    "num_days": 30,
+    "stocks": ["TECH", "ENERGY", "FINANCE"],
+    "variables": ["interest_rate", "oil_price", "market_sentiment"],
+    "dependency_matrix": [
+        [-5, 2, 3],
+        [1, 8, 2],
+        [-3, 1, 4]
+    ],
+    "initial_prices": [100, 80, 120],
+    "initial_variables": [0, 0, 0],
+    "initial_cash": 10000,
+    "price_noise_scale": 0,
+    "timeline": {
+        "day_1": {
+            "variable_changes": [0.1, -0.2, 0.3],
+            "news_text": "Federal Reserve hints at rate increase; Oil prices drop on oversupply concerns"
+        },
+        "day_2": {
+            "variable_changes": [-0.1, 0.3, 0.2],
+            "news_text": "Tech sector shows strong earnings; Energy stocks rally on production cuts"
+        },
+        "day_3": {
+            "variable_changes": [0.2, 0.1, -0.1],
+            "news_text": "Market sentiment cautious amid geopolitical tensions"
+        },
+        "day_4": {
+            "variable_changes": [0.0, 0.2, 0.1],
+            "news_text": "Stable interest rates; Energy sector momentum continues"
+        },
+        "day_5": {
+            "variable_changes": [-0.2, -0.1, 0.0],
+            "news_text": "Rate cut speculation; Market consolidation"
+        }
+    }
+}
+
+# Global state
+env = None
+history = []
+
+def initialize_env(config_file=None):
+    global env, history
+    
+    if config_file is not None:
+        try:
+            config = json.loads(config_file)
+        except:
+            return "❌ Invalid JSON file", None, None, None, None
+    else:
+        config = DEFAULT_CONFIG
+    
+    env = TradeArenaEnv_Deterministic(config)
+    obs = env.reset()
+    
+    # Initialize history
+    history = [{
+        'day': obs['day'],
+        'total_value': obs['total_value'],
+        **obs['prices']
+    }]
+    
+    status = f"✅ Session initialized!\n📅 Day: {obs['day']}\n💰 Cash: ${obs['cash']:.2f}\n📊 Total Value: ${obs['total_value']:.2f}"
+    
+    return (
+        status,
+        create_portfolio_display(obs),
+        create_news_display(obs),
+        create_price_chart(),
+        create_value_chart()
+    )
+
+def create_portfolio_display(obs):
+    """Create portfolio summary table"""
+    data = []
+    for stock in env.stocks:
+        data.append({
+            'Stock': stock,
+            'Price': f"${obs['prices'][stock]:.2f}",
+            'Holdings': obs['positions'][stock],
+            'Value': f"${obs['prices'][stock] * obs['positions'][stock]:.2f}"
+        })
+    
+    df = pd.DataFrame(data)
+    return df
+
+def create_news_display(obs):
+    """Create news display"""
+    if obs['news_next_day_text']:
+        news_html = f"""
+        <div style='background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+                    padding: 20px; border-radius: 10px; color: white;'>
+            <h3>📰 Next Day News</h3>
+            <p style='font-size: 16px;'>{obs['news_next_day_text']}</p>
+        """
+        if obs['news_next_day']:
+            news_html += "<p style='font-size: 14px; margin-top: 10px;'><b>Variable Changes:</b> "
+            for i, var in enumerate(env.variables):
+                change = obs['news_next_day'][i]
+                news_html += f"{var}: {'+' if change > 0 else ''}{change} | "
+            news_html += "</p>"
+        news_html += "</div>"
+        return news_html
+    else:
+        return "<div style='padding: 20px; background: #f0f0f0; border-radius: 10px;'>No more news available</div>"
+
+def create_price_chart():
+    """Create price history chart"""
+    if len(history) <= 1:
+        return None
+    
+    df = pd.DataFrame(history)
+    
+    fig = go.Figure()
+    colors = ['#3b82f6', '#10b981', '#f59e0b', '#ef4444', '#8b5cf6']
+    
+    for i, stock in enumerate(env.stocks):
+        fig.add_trace(go.Scatter(
+            x=df['day'],
+            y=df[stock],
+            mode='lines+markers',
+            name=stock,
+            line=dict(width=3, color=colors[i % len(colors)])
+        ))
+    
+    fig.update_layout(
+        title='Stock Price History',
+        xaxis_title='Day',
+        yaxis_title='Price ($)',
+        hovermode='x unified',
+        template='plotly_white',
+        height=400
+    )
+    
+    return fig
+
+def create_value_chart():
+    """Create portfolio value chart"""
+    if len(history) <= 1:
+        return None
+    
+    df = pd.DataFrame(history)
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(
+        x=df['day'],
+        y=df['total_value'],
+        mode='lines+markers',
+        name='Portfolio Value',
+        line=dict(width=4, color='#8b5cf6'),
+        fill='tozeroy',
+        fillcolor='rgba(139, 92, 246, 0.1)'
+    ))
+    
+    fig.update_layout(
+        title='Portfolio Value Over Time',
+        xaxis_title='Day',
+        yaxis_title='Total Value ($)',
+        template='plotly_white',
+        height=400
+    )
+    
+    return fig
+
+def execute_trade(stock, action, amount):
+    """Execute a buy or sell trade"""
+    global env, history
+    
+    if env is None:
+        return "❌ Please initialize the environment first", None, None, None, None
+    
+    try:
+        amount = int(amount)
+        if amount <= 0:
+            return "❌ Amount must be positive", None, None, None, None
+        
+        if action == "Buy":
+            trade_action = {"buy": {stock: amount}, "sell": {}}
+        else:
+            trade_action = {"buy": {}, "sell": {stock: amount}}
+        
+        # Execute trade (modify positions without advancing day)
+        if action == "Sell":
+            idx = env.stocks.index(stock)
+            qty = min(amount, env.positions[idx])
+            if qty == 0:
+                return f"❌ No shares to sell", None, None, None, None
+            revenue = env.prices[idx] * qty
+            env.positions[idx] -= qty
+            env.cash += revenue
+            status = f"✅ Sold {qty} shares of {stock} at ${env.prices[idx]:.2f}"
+        else:  # Buy
+            idx = env.stocks.index(stock)
+            cost = env.prices[idx] * amount
+            if cost > env.cash:
+                return f"❌ Insufficient cash! Need ${cost:.2f}, have ${env.cash:.2f}", None, None, None, None
+            env.positions[idx] += amount
+            env.cash -= cost
+            status = f"✅ Bought {amount} shares of {stock} at ${env.prices[idx]:.2f}"
+        
+        obs = env._get_observation()
+        status += f"\n💰 Cash: ${obs['cash']:.2f}\n📊 Total Value: ${obs['total_value']:.2f}"
+        
+        return (
+            status,
+            create_portfolio_display(obs),
+            create_news_display(obs),
+            create_price_chart(),
+            create_value_chart()
+        )
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}", None, None, None, None
+
+def advance_day():
+    """Advance to next day"""
+    global env, history
+    
+    if env is None:
+        return "❌ Please initialize the environment first", None, None, None, None
+    
+    try:
+        obs, reward, done, info = env.step({"buy": {}, "sell": {}})
+        
+        # Add to history
+        history.append({
+            'day': obs['day'],
+            'total_value': obs['total_value'],
+            **obs['prices']
+        })
+        
+        if done:
+            status = f"🏁 Simulation Complete!\n📅 Final Day: {obs['day']}\n💰 Final Cash: ${obs['cash']:.2f}\n📊 Final Value: ${obs['total_value']:.2f}"
+        else:
+            status = f"✅ Advanced to Day {obs['day']}\n💰 Cash: ${obs['cash']:.2f}\n📊 Total Value: ${obs['total_value']:.2f}"
+        
+        return (
+            status,
+            create_portfolio_display(obs),
+            create_news_display(obs),
+            create_price_chart(),
+            create_value_chart()
+        )
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}", None, None, None, None
+
+def reset_env():
+    """Reset the environment"""
+    global env, history
+    
+    if env is None:
+        return initialize_env()
+    
+    obs = env.reset()
+    history = [{
+        'day': obs['day'],
+        'total_value': obs['total_value'],
+        **obs['prices']
+    }]
+    
+    status = f"🔄 Environment Reset!\n📅 Day: {obs['day']}\n💰 Cash: ${obs['cash']:.2f}\n📊 Total Value: ${obs['total_value']:.2f}"
+    
+    return (
+        status,
+        create_portfolio_display(obs),
+        create_news_display(obs),
+        None,
+        None
+    )
+
+# Create Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Trading Arena") as demo:
+    gr.Markdown(
+        """
+        # 🚀 AI Trading Arena
+        ### Interactive Stock Trading Simulator
+        Upload your config or use the default configuration to start trading!
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## 🎮 Control Panel")
+            
+            with gr.Accordion("📁 Configuration", open=True):
+                config_input = gr.Textbox(
+                    label="Upload Config JSON (or leave empty for default)",
+                    placeholder='Paste JSON config here or leave empty',
+                    lines=5
+                )
+                init_btn = gr.Button("🚀 Initialize/Load Config", variant="primary", size="lg")
+                reset_btn = gr.Button("🔄 Reset Environment", variant="secondary")
+            
+            with gr.Accordion("💹 Trading", open=True):
+                stock_dropdown = gr.Dropdown(
+                    choices=DEFAULT_CONFIG["stocks"],
+                    label="Select Stock",
+                    value=DEFAULT_CONFIG["stocks"][0]
+                )
+                action_radio = gr.Radio(
+                    choices=["Buy", "Sell"],
+                    label="Action",
+                    value="Buy"
+                )
+                amount_input = gr.Number(
+                    label="Amount (shares)",
+                    value=1,
+                    minimum=1
+                )
+                trade_btn = gr.Button("📈 Execute Trade", variant="primary")
+            
+            advance_btn = gr.Button("⏭️ Advance to Next Day", variant="primary", size="lg")
+            
+            status_output = gr.Textbox(
+                label="📊 Status",
+                lines=5,
+                interactive=False
+            )
+        
+        with gr.Column(scale=2):
+            gr.Markdown("## 📊 Market Overview")
+            
+            portfolio_table = gr.Dataframe(
+                label="Portfolio Holdings",
+                interactive=False
+            )
+            
+            news_display = gr.HTML(label="News")
+            
+            with gr.Tabs():
+                with gr.Tab("📈 Price History"):
+                    price_chart = gr.Plot(label="Stock Prices")
+                
+                with gr.Tab("💰 Portfolio Value"):
+                    value_chart = gr.Plot(label="Total Value")
+    
+    # Event handlers
+    init_btn.click(
+        fn=initialize_env,
+        inputs=[config_input],
+        outputs=[status_output, portfolio_table, news_display, price_chart, value_chart]
+    )
+    
+    reset_btn.click(
+        fn=reset_env,
+        inputs=[],
+        outputs=[status_output, portfolio_table, news_display, price_chart, value_chart]
+    )
+    
+    trade_btn.click(
+        fn=execute_trade,
+        inputs=[stock_dropdown, action_radio, amount_input],
+        outputs=[status_output, portfolio_table, news_display, price_chart, value_chart]
+    )
+    
+    advance_btn.click(
+        fn=advance_day,
+        inputs=[],
+        outputs=[status_output, portfolio_table, news_display, price_chart, value_chart]
+    )
+    
+    # Initialize on load
+    demo.load(
+        fn=initialize_env,
+        inputs=[],
+        outputs=[status_output, portfolio_table, news_display, price_chart, value_chart]
+    )
+
+if __name__ == "__main__":
+    demo.launch()