Merge branch 'main' into codex/integrate-futu-api-for-data-collection-6d6t47

Author: jjckson

.github/workflows/python-package-conda.yml

@@ -0,0 +1,34 @@
+name: Python Package using Conda
+
+on: [push]
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 5
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Add conda to system path
+      run: |
+        # $CONDA is an environment variable pointing to the root of the miniconda directory
+        echo $CONDA/bin >> $GITHUB_PATH
+    - name: Install dependencies
+      run: |
+        conda env update --file environment.yml --name base
+    - name: Lint with flake8
+      run: |
+        conda install flake8
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        conda install pytest
+        pytest

environment.yml

@@ -0,0 +1,17 @@
+name: trading-dashboard
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - python>=3.10
+  - streamlit>=1.32
+  - pandas>=2.2
+  - numpy>=1.26
+  - httpx>=0.27
+  - python-dotenv>=1.0
+  - pip
+  - pip:
+    - futu-api>=7.2.4600
+    - pydantic>=2.7
+    - openai>=1.3
+    - pytest>=7.4

pyproject.toml

@@ -11,7 +11,10 @@ dependencies = [
   "pydantic>=2.7",
   "openai>=1.3",
   "httpx>=0.27",
-  "python-dotenv>=1.0"
+  "python-dotenv>=1.0",
+  "streamlit>=1.32",
+  "pandas>=2.2",
+  "numpy>=1.26"
 ]
 
 [project.optional-dependencies]

trading_dashboard/app.py

@@ -0,0 +1,137 @@
+"""Streamlit entry-point for the trading dashboard."""
+from __future__ import annotations
+
+import pandas as pd
+import streamlit as st
+
+from .executor import PaperTradeExecutor
+from .fetcher import MockMarketDataFetcher
+from .llm_client import LLMClient
+from .prompt_builder import PromptBuilder
+
+st.set_page_config(page_title="Trading Dashboard", layout="wide", page_icon="📈")
+
+
+def _init_state() -> None:
+    if "fetcher" not in st.session_state:
+        st.session_state.fetcher = MockMarketDataFetcher()
+    if "executor" not in st.session_state:
+        st.session_state.executor = PaperTradeExecutor()
+    if "llm_client" not in st.session_state:
+        st.session_state.llm_client = LLMClient()
+    if "prompt_builder" not in st.session_state:
+        st.session_state.prompt_builder = PromptBuilder()
+
+
+def _refresh_snapshot() -> None:
+    fetcher: MockMarketDataFetcher = st.session_state.fetcher
+    executor: PaperTradeExecutor = st.session_state.executor
+    llm_client: LLMClient = st.session_state.llm_client
+    prompt_builder: PromptBuilder = st.session_state.prompt_builder
+
+    market = fetcher.fetch_latest()
+    account = executor.get_account_state(market.price)
+    prompt = prompt_builder.build_prompt(market, account)
+    decision = llm_client.get_trading_decision(prompt)
+
+    st.session_state.market = market
+    st.session_state.account = account
+    st.session_state.prompt = prompt
+    st.session_state.decision = decision
+
+
+def _render_market_panel() -> None:
+    market = st.session_state.market
+    st.subheader("🔹 行情面板")
+    cols = st.columns(5)
+    cols[0].metric("价格", f"{market.price:.2f}")
+    cols[1].metric("EMA(20)", f"{market.ema:.2f}")
+    cols[2].metric("MACD", f"{market.macd:.4f}")
+    cols[3].metric("MACD Signal", f"{market.macd_signal:.4f}")
+    cols[4].metric("RSI", f"{market.rsi:.2f}")
+
+    st.metric("成交量", f"{market.volume:,.0f}")
+
+    history = market.history.copy()
+    history.set_index("time", inplace=True)
+    history.index = pd.to_datetime(history.index)
+    st.line_chart(history["close"], height=240)
+
+
+def _render_account_panel() -> None:
+    account = st.session_state.account
+    st.subheader("🔹 账户面板")
+    cols = st.columns(3)
+    cols[0].metric("账户价值", f"{account.total_value:,.2f}")
+    cols[1].metric("现金", f"{account.cash:,.2f}")
+    positions = ", ".join(f"{symbol}: {qty}" for symbol, qty in account.positions.items()) or "无"
+    cols[2].metric("持仓", positions)
+
+
+def _render_ai_panel() -> None:
+    st.subheader("🔹 AI 决策展示")
+    st.markdown(
+        "当前策略建议："
+        f"<span style='font-size:28px; font-weight:bold;'> {st.session_state.decision}</span>",
+        unsafe_allow_html=True,
+    )
+    with st.expander("查看 Prompt"):
+        st.code(st.session_state.prompt)
+
+
+def _render_order_panel() -> None:
+    st.subheader("🔹 模拟下单")
+    market = st.session_state.market
+    executor: PaperTradeExecutor = st.session_state.executor
+    action = st.selectbox(
+        "选择操作",
+        ["Buy", "Sell", "Hold"],
+        index=["Buy", "Sell", "Hold"].index(st.session_state.decision),
+    )
+    if st.button("执行下单"):
+        result = executor.execute(action, market)
+        st.success(f"{result.message} 数量: {result.quantity}, 价格: {result.price:.2f}")
+        st.session_state.account = executor.get_account_state(market.price)
+
+    if executor.order_history:
+        st.markdown("**订单历史**")
+        history_data = [
+            {
+                "时间": order.timestamp.strftime("%H:%M:%S"),
+                "操作": order.action,
+                "数量": order.quantity,
+                "价格": f"{order.price:.2f}",
+                "备注": order.message,
+            }
+            for order in reversed(executor.order_history[-10:])
+        ]
+        st.table(history_data)
+
+
+def main() -> None:
+    st.markdown("<meta http-equiv='refresh' content='180'>", unsafe_allow_html=True)
+    st.title("🚀 AI Trading Dashboard")
+    st.caption("最小可行闭环：实时行情 + 账户状态 + AI 策略 + 一键下单")
+
+    _init_state()
+
+    _refresh_snapshot()
+
+    if st.button("手动刷新"):
+        _refresh_snapshot()
+
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        _render_market_panel()
+    with col2:
+        _render_account_panel()
+
+    col3, col4 = st.columns(2)
+    with col3:
+        _render_ai_panel()
+    with col4:
+        _render_order_panel()
+
+
+if __name__ == "__main__":
+    main()

trading_dashboard/executor.py

@@ -0,0 +1,73 @@
+"""Paper trading execution utilities."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List
+
+from .fetcher import AccountState, MarketSnapshot
+
+
+@dataclass
+class OrderResult:
+    action: str
+    quantity: float
+    price: float
+    message: str
+    timestamp: datetime
+
+
+@dataclass
+class PaperTradeExecutor:
+    """Minimal in-memory execution engine used by the dashboard."""
+
+    symbol: str = "AAPL"
+    lot_size: float = 1.0
+    cash: float = 100_000.0
+    positions: Dict[str, float] = field(default_factory=dict)
+    order_history: List[OrderResult] = field(default_factory=list)
+
+    def get_account_state(self, market_price: float) -> AccountState:
+        position_qty = self.positions.get(self.symbol, 0.0)
+        position_value = position_qty * market_price
+        total_value = self.cash + position_value
+        return AccountState(
+            total_value=total_value,
+            cash=self.cash,
+            positions={self.symbol: position_qty},
+        )
+
+    def execute(self, action: str, market: MarketSnapshot) -> OrderResult:
+        action = action.capitalize()
+        if action not in {"Buy", "Sell", "Hold"}:
+            raise ValueError(f"Unsupported action: {action}")
+
+        qty = self.lot_size
+        price = market.price
+        position_qty = self.positions.get(self.symbol, 0.0)
+
+        now = datetime.utcnow()
+
+        if action == "Buy":
+            cost = qty * price
+            if cost > self.cash:
+                result = OrderResult(action, 0.0, price, "Insufficient cash to buy.", now)
+            else:
+                self.cash -= cost
+                self.positions[self.symbol] = position_qty + qty
+                result = OrderResult(action, qty, price, "Filled buy order.", now)
+        elif action == "Sell":
+            if position_qty < qty:
+                result = OrderResult(action, 0.0, price, "Not enough holdings to sell.", now)
+            else:
+                self.cash += qty * price
+                self.positions[self.symbol] = position_qty - qty
+                result = OrderResult(action, qty, price, "Filled sell order.", now)
+        else:  # Hold
+            result = OrderResult(action, 0.0, price, "No trade executed.", now)
+
+        self.order_history.append(result)
+        return result
+
+
+__all__ = ["OrderResult", "PaperTradeExecutor"]

trading_dashboard/fetcher.py

@@ -0,0 +1,121 @@
+"""Data fetching utilities for the Streamlit trading dashboard.
+
+This module currently provides a mock implementation that simulates price
+movements so the dashboard can run end-to-end without external market data
+providers. The API has been designed so a real implementation can replace the
+mock with minimal changes.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Dict
+
+import numpy as np
+import pandas as pd
+
+
+@dataclass
+class MarketSnapshot:
+    """Aggregated view of the latest market indicators."""
+
+    symbol: str
+    price: float
+    ema: float
+    macd: float
+    macd_signal: float
+    rsi: float
+    volume: float
+    history: pd.DataFrame
+
+
+@dataclass
+class AccountState:
+    """Basic representation of the account used in the dashboard."""
+
+    total_value: float
+    cash: float
+    positions: Dict[str, float]
+
+
+class MockMarketDataFetcher:
+    """Simulate a live market data feed.
+
+    The fetcher maintains an in-memory price series and generates technical
+    indicators – EMA, MACD, RSI, and volume – each time ``fetch_latest`` is
+    called. The historical data is kept in a pandas ``DataFrame`` to make chart
+    rendering straightforward inside Streamlit.
+    """
+
+    def __init__(self, symbol: str = "AAPL", history_points: int = 120) -> None:
+        self.symbol = symbol
+        self.history_points = history_points
+        self._history = self._generate_initial_history()
+
+    def _generate_initial_history(self) -> pd.DataFrame:
+        end = datetime.utcnow()
+        index = [end - timedelta(minutes=i) for i in reversed(range(self.history_points))]
+        base_price = 150.0
+        noise = np.random.normal(0, 0.5, size=self.history_points).cumsum()
+        close = base_price + noise
+        volume = np.random.randint(1_000, 10_000, size=self.history_points)
+        return pd.DataFrame({"time": index, "close": close, "volume": volume})
+
+    def _append_new_row(self) -> None:
+        last_price = float(self._history.iloc[-1]["close"])
+        drift = np.random.normal(0, 0.8)
+        new_price = max(0.01, last_price + drift)
+        new_row = {
+            "time": datetime.utcnow(),
+            "close": new_price,
+            "volume": int(np.random.randint(1_000, 10_000)),
+        }
+        self._history = pd.concat([self._history.iloc[1:], pd.DataFrame([new_row])], ignore_index=True)
+
+    def _compute_indicators(self, history: pd.DataFrame) -> Dict[str, float]:
+        closes = history["close"]
+        ema = closes.ewm(span=20, adjust=False).mean()
+        ema12 = closes.ewm(span=12, adjust=False).mean()
+        ema26 = closes.ewm(span=26, adjust=False).mean()
+        macd = ema12 - ema26
+        signal = macd.ewm(span=9, adjust=False).mean()
+
+        delta = closes.diff()
+        gain = delta.clip(lower=0)
+        loss = -delta.clip(upper=0)
+        avg_gain = gain.rolling(window=14).mean()
+        avg_loss = loss.rolling(window=14).mean()
+        rs = avg_gain / (avg_loss + 1e-9)
+        rsi = 100 - (100 / (1 + rs))
+
+        return {
+            "ema": float(ema.iloc[-1]),
+            "macd": float(macd.iloc[-1]),
+            "signal": float(signal.iloc[-1]),
+            "rsi": float(rsi.iloc[-1]),
+        }
+
+    def fetch_latest(self) -> MarketSnapshot:
+        """Return the newest snapshot and update internal state."""
+
+        self._append_new_row()
+        history = self._history.copy()
+        indicators = self._compute_indicators(history)
+        latest = history.iloc[-1]
+        return MarketSnapshot(
+            symbol=self.symbol,
+            price=float(latest["close"]),
+            ema=indicators["ema"],
+            macd=indicators["macd"],
+            macd_signal=indicators["signal"],
+            rsi=indicators["rsi"],
+            volume=float(latest["volume"]),
+            history=history,
+        )
+
+
+__all__ = [
+    "AccountState",
+    "MarketSnapshot",
+    "MockMarketDataFetcher",
+]