Quant Trading Systems: Architecture & Infrastructure › Putting It All Together

from datetime import datetime


class TradingSystem:
    """
    Simplified trading system integrating all components.
    Production systems would be significantly more complex.
    """

    def __init__(self, initial_capital: float):
        # Initialize components
        self.market_data = MarketDataHandler(buffer_size=1000)
        self.strategy = MomentumStrategy(
            ["AAPL", "GOOGL"], lookback=5, threshold=0.01
        )
        self.risk_checker = PreTradeRiskChecker(RiskLimits())
        self.oms = OrderManagementSystem()
        self.portfolio = PortfolioManager(initial_capital)
        self.circuit_breaker = CircuitBreaker()

        # System state
        self.is_running = False
        self.trade_log: list[dict] = []

    def start(self):
        """Start the trading system."""
        self.is_running = True
        print("Trading system started")

    def stop(self):
        """Stop the trading system gracefully."""
        self.is_running = False
        # Cancel all open orders
        for order in self.oms.get_open_orders():
            print(f"Cancelling open order: {order.order_id}")
        print("Trading system stopped")

    def on_market_data(self, symbol: str, price: float, bid: float, ask: float):
        """Process incoming market data."""
        if not self.is_running:
            return

        # Create tick and validate
        tick = MarketDataTick(
            symbol=symbol,
            timestamp=datetime.now(),
            bid_price=bid,
            ask_price=ask,
            bid_size=100,
            ask_size=100,
            last_price=price,
        )

        if not self.market_data.on_tick(tick):
            print(f"Invalid tick rejected for {symbol}")
            return

        # Update portfolio prices
        self.portfolio.update_prices({symbol: price})

        # Generate signals
        data = {symbol: price}
        signals = self.strategy.on_data(data)

        # Generate orders from signals
        self._process_signals(signals)

    def _process_signals(self, signals: dict[str, Signal]):
        """Convert signals to orders with risk checks."""
        if not self.circuit_breaker.can_trade():
            return

        target_positions = self.strategy.calculate_target_positions()
        portfolio_summary = self.portfolio.get_portfolio_summary()

        for symbol, target_weight in target_positions.items():
            if symbol not in self.market_data.current_quotes:
                continue

            current_price = self.market_data.current_quotes[symbol].mid_price
            current_position = self.portfolio.positions.get(
                symbol, Position(symbol, 0, 0)
            ).quantity

            # Calculate target shares
            target_notional = target_weight * portfolio_summary["nav"]
            target_shares = target_notional / current_price
            shares_to_trade = target_shares - current_position

            if abs(shares_to_trade) < 1:
                continue

            # Determine order side
            side = "BUY" if shares_to_trade > 0 else "SELL"
            quantity = abs(shares_to_trade)

            # Create and check order
            order = Order(symbol, side, quantity, "MARKET")

            approved, reason = self.risk_checker.check_order(
                order=order,
                current_position=current_position,
                portfolio_value=portfolio_summary["nav"],
                current_price=current_price,
                total_exposure=portfolio_summary["market_value"],
                daily_pnl=portfolio_summary["total_pnl"],
            )

            if approved:
                order_id = self.oms.create_order(
                    symbol, side, quantity, "MARKET"
                )
                self.oms.submit_order(order_id)

                # Simulate immediate fill for demonstration
                self.oms.on_fill(order_id, quantity, current_price)
                self.portfolio.update_position(
                    symbol,
                    quantity if side == "BUY" else -quantity,
                    current_price,
                )

                self.trade_log.append(
                    {
                        "time": datetime.now(),
                        "order_id": order_id,
                        "symbol": symbol,
                        "side": side,
                        "quantity": quantity,
                        "price": current_price,
                    }
                )
                print(
                    f"Order submitted and filled: {side} {quantity:.0f} {symbol} @ {current_price:.2f}"
                )
            else:
                print(f"Order rejected: {reason}")

# Demonstrate integrated system
system = TradingSystem(initial_capital=500000)
system.start()

# Simulate market data updates
np.random.seed(42)
prices = {"AAPL": 185.0, "GOOGL": 141.0}

system_log = []
for minute in range(10):
    # Simulate price movements
    for symbol in prices:
        change = np.random.normal(0, 0.005)  # 0.5% volatility
        prices[symbol] *= 1 + change

        # Generate realistic bid/ask
        spread = prices[symbol] * 0.0005  # 5 bps spread
        bid = prices[symbol] - spread / 2
        ask = prices[symbol] + spread / 2

        system.on_market_data(symbol, prices[symbol], bid, ask)

    if minute % 3 == 0:  # Print status every 3 minutes
        summary = system.portfolio.get_portfolio_summary()
        system_log.append(
            f"\nMinute {minute}: NAV = ${summary['nav']:,.2f}, "
            f"P&L = ${summary['total_pnl']:,.2f}"
        )

system.stop()

final_summary = system.portfolio.get_portfolio_summary()