# 推荐：ib_async（活跃维护版）
pip install ib_async

# 或者：ib_insync（经典版，代码兼容）
# pip install ib_insync

# 依赖
pip install pandas  # DataFrame 支持

from ib_async import IB

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)  # Paper Trading
print(f"Connected. Server version: {ib.client.serverVersion()}")

# ... 你的业务代码 ...

ib.disconnect()

from ib_async import IB, util
util.startLoop()  # 必须！在 notebook 中启用事件循环

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

import asyncio
from ib_async import IB

async def main():
    ib = IB()
    await ib.connectAsync('127.0.0.1', 4002, clientId=1)
    # ... async 业务代码 ...
    ib.disconnect()

asyncio.run(main())

from ib_async import IB

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

# 获取账户列表
accounts = ib.managedAccounts()
print(f"Accounts: {accounts}")

# 账户摘要（净值、购买力等）
summary = ib.accountSummary()
for item in summary:
    if item.tag in ('NetLiquidation', 'TotalCashValue', 'BuyingPower'):
        print(f"  {item.tag}: ${float(item.value):,.2f}")

# 当前持仓
positions = ib.positions()
for pos in positions:
    print(f"  {pos.contract.symbol}: {pos.position} shares @ ${pos.avgCost:.2f}")

# 组合 P&L
pnl = ib.pnl()
for p in pnl:
    print(f"  Daily P&L: ${p.dailyPnL:.2f}, Unrealized: ${p.unrealizedPnL:.2f}")

ib.disconnect()

from ib_async import IB, Stock

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

# 如果没有实时数据订阅，先切换到延迟数据
ib.reqMarketDataType(3)  # 3=Delayed, 1=Live, 4=Delayed-Frozen

# Plan E3-AW 核心标的
contracts = [
    Stock('DBMF', 'SMART', 'USD'),  # 趋势跟踪 ETF
    Stock('GLD', 'SMART', 'USD'),   # 黄金 ETF
    Stock('BIL', 'SMART', 'USD'),   # 短期国债 ETF
]

# 验证合约（重要！下单前必须做）
for c in contracts:
    ib.qualifyContracts(c)
    print(f"Qualified: {c.symbol} (conId={c.conId})")

# 请求实时报价
tickers = ib.reqTickers(*contracts)
for t in tickers:
    print(f"  {t.contract.symbol}: bid={t.bid}, ask={t.ask}, last={t.last}")

ib.disconnect()

from ib_async import IB, Stock, util

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

contract = Stock('GLD', 'SMART', 'USD')
ib.qualifyContracts(contract)

# 获取近 6 个月日线
bars = ib.reqHistoricalData(
    contract,
    endDateTime='',           # 空字符串 = 当前时间
    durationStr='6 M',        # 6 个月
    barSizeSetting='1 day',   # 日线
    whatToShow='TRADES',      # 成交数据
    useRTH=True,              # 只要常规交易时段
    formatDate=1
)

df = util.df(bars)
print(df.tail())
print(f"\nTotal bars: {len(df)}")

ib.disconnect()

from ib_async import IB, Stock, MarketOrder

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

contract = Stock('GLD', 'SMART', 'USD')
ib.qualifyContracts(contract)

# 买入 10 股 GLD
order = MarketOrder('BUY', 10)
trade = ib.placeOrder(contract, order)

# 等待成交
while not trade.isDone():
    ib.sleep(1)
    print(f"  Status: {trade.orderStatus.status}")

print(f"\nFilled: {trade.orderStatus.filled} @ ${trade.orderStatus.avgFillPrice:.2f}")
ib.disconnect()

from ib_async import IB, Stock, LimitOrder

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

contract = Stock('BIL', 'SMART', 'USD')
ib.qualifyContracts(contract)

# 限价买入：最高出价 $91.50
order = LimitOrder('BUY', 50, 91.50)
order.tif = 'DAY'  # 当日有效（也可以用 'GTC' = 直到取消）
trade = ib.placeOrder(contract, order)

print(f"Order placed: {trade.order.orderId}")
ib.disconnect()

from ib_async import IB, Stock, Order

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

contract = Stock('DBMF', 'SMART', 'USD')
ib.qualifyContracts(contract)

# MOC 单：以收盘价成交（再平衡最优选择）
order = Order()
order.action = 'BUY'
order.totalQuantity = 20
order.orderType = 'MOC'  # Market on Close
order.tif = 'DAY'        # MOC 必须是 DAY 有效期

trade = ib.placeOrder(contract, order)
print(f"MOC order placed: {trade.order.orderId}")

# MOC 重要限制：
# - 必须在收盘前 15 分钟提交（NYSE 规则，即 15:45 ET 之前）
# - 过了截止时间会被拒绝
ib.disconnect()

from ib_async import IB

ib = IB()
ib.connect('127.0.0.1', 4002, clientId=1)

# 所有活跃订单
open_trades = ib.openTrades()
for t in open_trades:
    print(f"  {t.contract.symbol} {t.order.action} {t.order.totalQuantity} "
          f"type={t.order.orderType} status={t.orderStatus.status}")

# 今日成交记录
fills = ib.fills()
for f in fills:
    print(f"  {f.contract.symbol}: {f.execution.side} {f.execution.shares} "
          f"@ ${f.execution.price:.2f} time={f.execution.time}")

# 佣金报告
executions = ib.executions()
for e in executions:
    print(f"  Commission: ${e.commissionReport.commission:.2f}")

# 事件回调方式（生产推荐）
def on_order_status(trade):
    print(f"  [Callback] {trade.contract.symbol}: {trade.orderStatus.status}")

ib.orderStatusEvent += on_order_status

ib.disconnect()

"""
Plan E3-AW Rebalancer Prototype
================================
自动读取持仓 -> 计算偏离 -> 生成 MOC 订单 -> 执行再平衡

依赖: pip install ib_async pandas
连接: IB Gateway Paper Trading (port 4002)
"""

import logging
from datetime import datetime
from dataclasses import dataclass

from ib_async import IB, Stock, Order, util

# -- 配置 -----------------------------------------
TARGET_WEIGHTS = {
    'DBMF': 0.25,   # 趋势跟踪
    'GLD':  0.25,   # 黄金
    'BIL':  0.25,   # 短期国债
}
# 三个 ETF 占 75%，剩余 25% 为 sUSDe（链上管理）
# IBKR 内的目标权重应归一化：
IBKR_WEIGHTS = {k: v / 0.75 for k, v in TARGET_WEIGHTS.items()}
# DBMF: 0.3333, GLD: 0.3333, BIL: 0.3333

DRIFT_THRESHOLD = 0.05   # 5% 偏离阈值
MIN_TRADE_VALUE = 100     # 最小交易金额
IB_HOST = '127.0.0.1'
IB_PORT = 4002            # Paper: 4002, Live: 4001
CLIENT_ID = 10            # 再平衡专用 clientId

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler(f'rebalance_{datetime.now():%Y%m%d}.log'),
        logging.StreamHandler()
    ]
)
log = logging.getLogger('rebalancer')


@dataclass
class PositionInfo:
    symbol: str
    shares: float
    avg_cost: float
    market_value: float
    current_weight: float
    target_weight: float
    drift: float


def get_positions(ib: IB):
    """读取当前持仓和 IBKR 账户净值"""
    summary = ib.accountSummary()
    net_liq = 0.0
    for item in summary:
        if item.tag == 'NetLiquidation':
            net_liq = float(item.value)
            break

    positions = {}
    for pos in ib.positions():
        sym = pos.contract.symbol
        if sym in IBKR_WEIGHTS:
            positions[sym] = {
                'shares': float(pos.position),
                'avg_cost': float(pos.avgCost),
            }

    return positions, net_liq


def calculate_drift(positions: dict, net_liq: float, prices: dict):
    """计算各标的权重偏离度"""
    result = []

    for symbol, target_w in IBKR_WEIGHTS.items():
        pos = positions.get(symbol, {'shares': 0, 'avg_cost': 0})
        price = prices.get(symbol, 0)

        market_value = pos['shares'] * price
        current_weight = market_value / net_liq if net_liq > 0 else 0
        drift = current_weight - target_w

        result.append(PositionInfo(
            symbol=symbol,
            shares=pos['shares'],
            avg_cost=pos['avg_cost'],
            market_value=market_value,
            current_weight=current_weight,
            target_weight=target_w,
            drift=drift,
        ))

    return result


def generate_orders(drift_info: list, net_liq: float, prices: dict):
    """生成再平衡订单（先卖后买排序）"""
    orders = []

    for info in drift_info:
        if abs(info.drift) < DRIFT_THRESHOLD:
            log.info(f"  {info.symbol}: drift={info.drift:+.2%} < threshold, skip")
            continue

        target_value = info.target_weight * net_liq
        current_value = info.market_value
        delta_value = target_value - current_value

        if abs(delta_value) < MIN_TRADE_VALUE:
            log.info(f"  {info.symbol}: delta=${delta_value:.0f} < min, skip")
            continue

        price = prices[info.symbol]
        delta_shares = int(delta_value / price)

        if delta_shares == 0:
            continue

        action = 'BUY' if delta_shares > 0 else 'SELL'
        orders.append({
            'symbol': info.symbol,
            'action': action,
            'quantity': abs(delta_shares),
            'est_value': abs(delta_shares * price),
            'drift': info.drift,
        })

    # 先卖后买
    orders.sort(key=lambda x: (x['action'] == 'BUY', -x['est_value']))

    return orders


def execute_rebalance(ib: IB, orders: list, dry_run: bool = True):
    """执行再平衡订单"""
    contracts = {}
    for o in orders:
        c = Stock(o['symbol'], 'SMART', 'USD')
        ib.qualifyContracts(c)
        contracts[o['symbol']] = c

    trades = []
    for o in orders:
        contract = contracts[o['symbol']]

        # 使用 MOC 单（Market on Close）
        order = Order()
        order.action = o['action']
        order.totalQuantity = o['quantity']
        order.orderType = 'MOC'
        order.tif = 'DAY'

        if dry_run:
            log.info(f"  [DRY RUN] {o['action']} {o['quantity']} {o['symbol']} "
                     f"MOC (~${o['est_value']:.0f})")
        else:
            trade = ib.placeOrder(contract, order)
            trades.append(trade)
            log.info(f"  [LIVE] {o['action']} {o['quantity']} {o['symbol']} "
                     f"MOC orderId={trade.order.orderId}")

    # 等待所有订单完成（MOC 在收盘时成交）
    if not dry_run and trades:
        log.info("Waiting for MOC fills (will fill at market close)...")
        for trade in trades:
            timeout = 7200  # 2 hours
            while not trade.isDone() and timeout > 0:
                ib.sleep(10)
                timeout -= 10
            if trade.isDone():
                log.info(f"  OK {trade.contract.symbol}: filled "
                         f"{trade.orderStatus.filled} @ ${trade.orderStatus.avgFillPrice:.2f}")
            else:
                log.warning(f"  WARN {trade.contract.symbol}: not filled yet, "
                            f"status={trade.orderStatus.status}")

    return trades


def main(dry_run: bool = True):
    """主入口"""
    log.info("=" * 60)
    log.info(f"Plan E3-AW Rebalancer {'[DRY RUN]' if dry_run else '[LIVE]'}")
    log.info(f"Time: {datetime.now():%Y-%m-%d %H:%M:%S}")
    log.info("=" * 60)

    ib = IB()
    try:
        ib.connect(IB_HOST, IB_PORT, clientId=CLIENT_ID)
        log.info(f"Connected to IB Gateway (port {IB_PORT})")

        # Step 1: 读取持仓
        positions, net_liq = get_positions(ib)
        log.info(f"IBKR Net Liquidation: ${net_liq:,.2f}")

        # Step 2: 获取价格
        ib.reqMarketDataType(3)  # 延迟数据
        prices = {}
        for symbol in IBKR_WEIGHTS:
            contract = Stock(symbol, 'SMART', 'USD')
            ib.qualifyContracts(contract)
            ticker = ib.reqTickers(contract)[0]
            price = ticker.last or ticker.close or ticker.marketPrice()
            prices[symbol] = price
            log.info(f"  {symbol}: ${price:.2f}")

        # Step 3: 计算偏离
        drift_info = calculate_drift(positions, net_liq, prices)
        log.info("Drift Report:")
        for info in drift_info:
            status = "REBALANCE" if abs(info.drift) >= DRIFT_THRESHOLD else "OK"
            log.info(f"  {info.symbol}: current={info.current_weight:.1%} "
                     f"target={info.target_weight:.1%} "
                     f"drift={info.drift:+.1%} {status}")

        # Step 4: 生成订单
        orders = generate_orders(drift_info, net_liq, prices)
        if not orders:
            log.info("No rebalance needed. All positions within threshold.")
            return

        log.info(f"Generated {len(orders)} orders:")
        for o in orders:
            log.info(f"  {o['action']} {o['quantity']} {o['symbol']} "
                     f"(~${o['est_value']:.0f}, drift={o['drift']:+.1%})")

        # Step 5: 执行
        execute_rebalance(ib, orders, dry_run=dry_run)

        log.info("Rebalance complete.")

    except Exception as e:
        log.error(f"Error: {e}", exc_info=True)
    finally:
        ib.disconnect()
        log.info("Disconnected.")


if __name__ == '__main__':
    import argparse
    parser =    parser = argparse.ArgumentParser()
    parser.add_argument('--live', action='store_true', help='Execute real orders')
    args = parser.parse_args()
    main(dry_run=not args.live)

# generate_orders() 中的排序逻辑
orders.sort(key=lambda x: (x['action'] == 'BUY', -x['est_value']))
# 结果：SELL 订单排在 BUY 之前，大额优先

def on_disconnect():
    log.warning("Connection lost! Attempting reconnect...")
    for i in range(3):
        try:
            ib.sleep(5)
            ib.connect(IB_HOST, IB_PORT, clientId=CLIENT_ID)
            log.info("Reconnected successfully")
            return
        except Exception:
            log.warning(f"Reconnect attempt {i+1}/3 failed")
    log.error("Failed to reconnect after 3 attempts. Manual intervention needed.")

ib.disconnectedEvent += on_disconnect

def on_error(reqId, errorCode, errorString, advancedOrderRejectJson):
    if errorCode == 201:  # Order rejected
        log.error(f"Order REJECTED: {errorString}")
        # 常见原因：余额不足、超出交易时间、合约无效
    elif errorCode == 202:  # Order cancelled
        log.warning(f"Order cancelled: {errorString}")
    elif errorCode in (2104, 2106, 2158):  # Market data farm connected
        log.debug(f"Info: {errorString}")  # 不是真正的错误
    else:
        log.warning(f"Error {errorCode}: {errorString}")

ib.errorEvent += on_error

# MOC 单通常全量成交，但以防万一
def check_fills(trades):
    for trade in trades:
        filled = trade.orderStatus.filled
        remaining = trade.orderStatus.remaining
        if remaining > 0:
            log.warning(f"Partial fill: {trade.contract.symbol} "
                        f"filled={filled}, remaining={remaining}")
            # 策略：保持部分成交，下次再平衡自动修正
            # 不追单，避免增加交易成本

import json
from pathlib import Path

def save_rebalance_log(drift_info, orders, trades, net_liq):
    """保存再平衡日志到 JSON（供 Dashboard 读取）"""
    log_entry = {
        'timestamp': datetime.now().isoformat(),
        'net_liquidation': net_liq,
        'drift_report': [
            {
                'symbol': d.symbol,
                'current_weight': round(d.current_weight, 4),
                'target_weight': round(d.target_weight, 4),
                'drift': round(d.drift, 4),
            }
            for d in drift_info
        ],
        'orders': orders,
        'execution': [
            {
                'symbol': t.contract.symbol,
                'status': t.orderStatus.status,
                'filled': float(t.orderStatus.filled),
                'avg_price': float(t.orderStatus.avgFillPrice),
            }
            for t in (trades or [])
        ],
    }

    # 追加到日志文件
    log_dir = Path('~/.tradesys/logs').expanduser()
    log_dir.mkdir(parents=True, exist_ok=True)
    log_file = log_dir / f"rebalance_{datetime.now():%Y%m}.jsonl"

    with open(log_file, 'a') as f:
        f.write(json.dumps(log_entry, ensure_ascii=False) + '\n')

    log.info(f"Log saved to {log_file}")

# 下载 Stable 版本（更稳定）
open https://www.interactivebrokers.com/en/trading/ibgateway-stable.php

# 安装后首次运行，登录并配置
# Configure -> Settings -> API:
#   - Enable ActiveX and Socket Clients: CHECKED
#   - Socket port: 4001 (Live) / 4002 (Paper)
#   - Trusted IPs: 127.0.0.1
#   - Read-Only API: UNCHECKED
#   - Download open orders on connection: CHECKED
# Configure -> Settings -> Memory Allocation: 4096 MB

# 防止 Mac 睡眠导致 Gateway 断连
caffeinate -i -w $(pgrep -f "IB Gateway") &

# 或者使用 pmset 设置系统不睡眠
sudo pmset -c sleep 0  # 插电时不睡眠

#!/bin/bash
# ~/bin/ib-gateway-watchdog.sh

GATEWAY_APP="/Applications/IB Gateway 10.28/IB Gateway.app"
LOG_FILE="$HOME/.tradesys/ib-gateway.log"

while true; do
    if ! pgrep -f "IB Gateway" > /dev/null; then
        echo "$(date): IB Gateway not running, starting..." >> "$LOG_FILE"
        open "$GATEWAY_APP"
        sleep 60  # 等待启动
    fi
    sleep 60
done

# 编辑 crontab
crontab -e

# 每月最后一个交易日 14:30 ET（收盘前 1 小时）执行再平衡
# 注意：需要转换为本地时区（北京时间 = ET + 12h）
# 北京时间 02:30 执行 = ET 14:30 前一天

# 每月最后一个工作日 02:30 执行
30 2 * * * [ $(date +\%u) -le 5 ] && /usr/local/bin/python3 /Users/mac/tradesys/rebalancer.py --live >> /Users/mac/.tradesys/cron.log 2>&1

# 更精确：每月最后一个交易日（需要脚本判断）
# 创建 wrapper 脚本

#!/usr/bin/env python3
# ~/bin/run-if-last-trading-day.py
import calendar
from datetime import datetime, timedelta

def is_last_trading_day_of_month():
    """判断今天是否是本月最后一个交易日"""
    today = datetime.now()
    last_day = calendar.monthrange(today.year, today.month)[1]
    last_date = datetime(today.year, today.month, last_day)
    
    # 回退到周五（如果是周末）
    while last_date.weekday() >= 5:  # 5=Sat, 6=Sun
        last_date -= timedelta(days=1)
    
    return today.date() == last_date.date()

if __name__ == '__main__':
    if is_last_trading_day_of_month():
        print(f"{datetime.now()}: Today is the last trading day. Running rebalancer...")
        import subprocess
        subprocess.run([
            '/usr/local/bin/python3',
            '/Users/mac/tradesys/rebalancer.py',
            '--live'
        ])
    else:
        print(f"{datetime.now()}: Not the last trading day. Skipping.")

# 每天 02:30 检查，如果是最后一个交易日则执行
30 2 * * * /usr/local/bin/python3 /Users/mac/bin/run-if-last-trading-day.py >> /Users/mac/.tradesys/cron.log 2>&1

<!-- ~/Library/LaunchAgents/com.tradesys.rebalancer.plist -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.tradesys.rebalancer</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/python3</string>
        <string>/Users/mac/tradesys/rebalancer.py</string>
        <string>--live</string>
    </array>
    <key>StartCalendarInterval</key>
    <dict>
        <key>Hour</key>
        <integer>2</integer>
        <key>Minute</key>
        <integer>30</integer>
        <key>Weekday</key>
        <integer>5</integer>  <!-- 周五 -->
    </dict>
    <key>StandardOutPath</key>
    <string>/Users/mac/.tradesys/rebalancer.log</string>
    <key>StandardErrorPath</key>
    <string>/Users/mac/.tradesys/rebalancer.error.log</string>
</dict>
</plist>

# 加载 launchd 配置
launchctl load ~/Library/LaunchAgents/com.tradesys.rebalancer.plist
launchctl start com.tradesys.rebalancer

# ~/.tradesys/config.py - 不要提交到 git
IB_HOST = '127.0.0.1'
IB_PORT = 4001  # 实盘
IB_CLIENT_ID = 10

# 或者使用环境变量
import os
IB_PORT = int(os.getenv('IB_PORT', 4002))  # 默认 paper

# ~/.zshrc
export IB_PORT=4001  # 实盘
export TRADESYS_LOG_LEVEL=INFO

# 确保配置文件只有用户可读
chmod 600 ~/.tradesys/config.py

# 日志目录
chmod 700 ~/.tradesys/