Architecture

hummingbot/
├── client/              # CLI interface and user interaction
├── connector/           # Exchange connectors
│   ├── derivative/      # Perpetual/futures connectors
│   ├── exchange/        # Spot exchange connectors
│   ├── gateway/         # Gateway DEX connectors
│   ├── other/           # Misc connectors
│   ├── test_support/    # Testing utilities for connectors
│   └── utilities/       # Helper functions for connectors
├── core/                # Core infrastructure
│   ├── api_throttler/   # Rate limiting mechanism
│   ├── cpp/             # High-performance C++ data types
│   ├── data_type/       # Core data structures
│   ├── event/           # Event system and event types
│   ├── gateway/         # Gateway middleware components
│   ├── management/      # Console and diagnostic tools
│   ├── rate_oracle/     # Exchange rate data sources
│   ├── utils/           # Utility functions and bot plugins
│   └── web_assistant/   # HTTP/WebSocket helpers
├── data_feed/           # Price feeds (CoinCap, etc.)
├── logger/              # Logging infrastructure
├── model/               # Database models and market data structures
├── notifier/            # Notification service connectors
├── remote_iface/        # Remote interfaces (MQTT, etc.)
├── strategy/            # Built-in strategies (legacy)
├── strategy_v2/         # V2 Strategy Framework
│   ├── backtesting/     # Backtesting engine and simulators
│   ├── controllers/     # Controller base classes
│   ├── executors/       # Executor implementations
│   ├── models/          # Data models for V2 framework
│   └── utils/           # V2 utility functions
├── templates/           # Configuration file templates
└── user/                # User-specific data (balances, etc.)

class ConnectorBase:
    # Get current price
    def get_price_by_type(self, trading_pair: str, price_type: PriceType)
    
    # Place orders
    def buy(self, trading_pair: str, amount: Decimal, order_type: OrderType, price: Decimal)
    def sell(self, trading_pair: str, amount: Decimal, order_type: OrderType, price: Decimal)
    
    # Cancel orders
    def cancel(self, trading_pair: str, order_id: str)
    
    # Get balances
    def get_balance(self, currency: str) -> Decimal
    
    # Budget validation
    budget_checker.adjust_candidates(candidates: List[OrderCandidate])

# Core events in core/event/events.py
class OrderFilledEvent:
    """Triggered when an order is filled"""
    trading_pair: str
    trade_type: TradeType
    price: Decimal
    amount: Decimal
    timestamp: float

class BuyOrderCreatedEvent:
    """Triggered when a buy order is created"""
    
class SellOrderCreatedEvent:
    """Triggered when a sell order is created"""
    
class OrderCancelledEvent:
    """Triggered when an order is cancelled"""

class MyStrategy(StrategyV2Base):
    def did_fill_order(self, event: OrderFilledEvent):
        # React to filled orders
        pass
    
    def did_create_buy_order(self, event: BuyOrderCreatedEvent):
        # React to created orders
        pass

class DManV3Controller(DirectionalTradingControllerBase):
    """
    Dynamic Market Making controller using Bollinger Bands
    and DCA (Dollar Cost Averaging) executors
    """
    
    def __init__(self, config: DManV3ControllerConfig, *args, **kwargs):
        super().__init__(config, *args, **kwargs)
        self.config = config
    
    def on_tick(self):
        # Analyze market conditions
        candles = self.get_candles()
        bb_bands = self.calculate_bollinger_bands(candles)
        
        # Determine signal
        if self.should_enter_long(bb_bands):
            # Create DCA executor for long position
            executor_config = self.create_dca_config(TradeType.BUY)
            self.create_executor(executor_config)
        
        elif self.should_enter_short(bb_bands):
            # Create DCA executor for short position
            executor_config = self.create_dca_config(TradeType.SELL)
            self.create_executor(executor_config)

class ExecutorOrchestrator:
    def execute_actions(self, actions: List[ExecutorAction]):
        """Process create/stop executor actions"""
        
    def execute_action(self, action: ExecutorAction):
        if isinstance(action, CreateExecutorAction):
            self.create_executor(action)
        elif isinstance(action, StopExecutorAction):
            self.stop_executor(action)
    
    def create_executor(self, action: CreateExecutorAction):
        """Instantiate and start an executor"""
        
    def stop_executor(self, action: StopExecutorAction):
        """Stop and clean up an executor"""

class V2WithControllers(StrategyV2Base):
    def __init__(self, connectors: Dict[str, ConnectorBase], config: V2WithControllersConfig):
        super().__init__(connectors, config)
        self.config = config
        # Controllers are loaded from config.controllers_config
    
    def on_tick(self):
        super().on_tick()  # Updates controllers and executors
        
        if not self._is_stop_triggered:
            self.check_manual_kill_switch()
            self.control_max_drawdown()
            self.send_performance_report()
    
    def control_max_drawdown(self):
        """Stop controllers that exceed max drawdown"""
        for controller_id, controller in self.controllers.items():
            controller_pnl = self.get_performance_report(controller_id).global_pnl_quote
            
            if self.is_drawdown_exceeded(controller_pnl):
                controller.stop()
                # Stop executors that haven't placed orders yet
                self.executor_orchestrator.execute_actions([
                    StopExecutorAction(controller_id=controller_id, executor_id=executor.id)
                    for executor in self.get_non_trading_executors(controller_id)
                ])

from hummingbot.strategy_v2.backtesting.backtesting_engine_base import BacktestingEngineBase

class MyBacktester(BacktestingEngineBase):
    def run_backtest(self, start_time: int, end_time: int):
        # Load historical candle data
        candles = self.load_candles(start_time, end_time)
        
        # Simulate strategy execution
        for candle in candles:
            self.process_tick(candle)
        
        # Generate performance report
        return self.get_performance_metrics()

from pydantic import Field
from hummingbot.strategy.strategy_v2_base import StrategyV2ConfigBase

class MyStrategyConfig(StrategyV2ConfigBase):
    script_file_name: str = "my_strategy.py"
    controllers_config: List[str] = ["pmm_simple", "dman_v3"]
    
    exchange: str = Field("binance", prompt="Enter exchange: ")
    trading_pair: str = Field("BTC-USDT", prompt="Enter trading pair: ")
    order_amount: Decimal = Field(Decimal("0.01"), prompt="Enter order amount: ")
    
    def update_markets(self, markets: MarketDict) -> MarketDict:
        """Register required markets"""
        markets[self.exchange] = markets.get(self.exchange, set()) | {self.trading_pair}
        return markets