This project has been refactored into a modular architecture for better maintainability, testability, and extensibility. The system implements a dynamic grid trading strategy with adaptive spacing, regime detection, and comprehensive backtesting capabilities.

workspace/
├── main.py              # Main entry point and CLI
├── config.py            # Configuration and constants
├── models.py            # Data models (Order, etc.)
├── persistence.py       # Database persistence layer
├── market.py            # Market data handling and indicators
├── order_manager.py     # Order management (Sim + Live)
├── detectors.py         # Technical analysis detectors
├── grid_manager.py      # Grid management logic
├── strategy.py          # Main strategy orchestrator
├── visualizer.py        # HTML report generation
├── test_modules.py      # Unit tests
└── dynamic_grid_v2.py   # Original monolithic file (deprecated)

• Default configuration parameters
• Parameter recommendations and rationale
• Configuration validation

• Order dataclass with validation
• Business logic for order state management
• Type safety and data integrity

• SQLite database operations
• CRUD operations for orders, trades, events, PnL
• Data migration and backup utilities

• Real-time market data handling
• OHLC candle construction
• Technical indicators (ATR, etc.)
• Market statistics

• Abstract base class for order managers
• SimOrderManager for backtesting
• OKXOrderManager for live trading (skeleton)
• Position and balance tracking

• RegimeDetector using ADX for trend/range detection
• BreakoutDetector with ATR confirmation
• Support/resistance level identification

• Dynamic grid construction and management
• Adaptive spacing based on market conditions
• Automatic rebalancing on fills
• Grid status monitoring

• Main strategy orchestrator
• Component coordination
• Market feed management
• Simulation and replay modes

• Plotly-based HTML report generation
• Trading performance visualization
• Summary statistics calculation

• Command-line interface
• Argument parsing and validation
• Application lifecycle management
• Logging configuration

pip install pandas numpy plotly python-dateutil aiohttp websockets pyyaml

python main.py --mode dry-run --pair BTC-USDT --initial-price 60000

python main.py --mode replay --replay-file data/btc_ticks.csv --replay-speed 5

python main.py --mode live --api-key YOUR_KEY --api-secret YOUR_SECRET --api-pass YOUR_PASSPHRASE

python main.py --config my_config.yaml --mode dry-run

Create a YAML configuration file (config.yaml):

pair: "BTC-USDT"
base_order_usd: 50
max_open_orders: 8
grid_layers: 3
spacing_base_pct: 0.002
spacing_min_pct: 0.0005
atr_period: 14
atr_tp_mult: 1.8
atr_sl_mult: 1.2
regime_adx_period: 14
regime_adx_threshold: 25
breakout_lookback: 20
breakout_atr_mult: 0.6
safe_mode: true
safe_max_drawdown_pct: 0.10
safe_max_consecutive_losses: 5
trade_cooldown_s: 2
replay_speed: 1.0

Run the unit tests to verify modularization:

python test_modules.py

The test suite covers:

• Model validation
• Market data handling
• Database operations
• Order management
• Technical analysis
• Grid management

1. New Order Manager: Extend BaseOrderManager in order_manager.py
2. New Detectors: Add to detectors.py following existing patterns
3. New Visualizations: Extend Visualizer class in visualizer.py
4. Configuration: Add parameters to config.py

• Use type hints for all function signatures
• Follow PEP 8 naming conventions
• Add comprehensive docstrings
• Write unit tests for new functionality
• Use dependency injection for testability

• Unit tests for individual components
• Integration tests for component interaction
• Mock external dependencies (APIs, databases)
• Test edge cases and error conditions

1. Testability: Each module can be tested in isolation
2. Maintainability: Clear separation of concerns
3. Extensibility: Easy to add new features or exchanges
4. Reusability: Components can be reused in other projects
5. Debugging: Easier to isolate and fix issues
6. Collaboration: Multiple developers can work on different modules

The original dynamic_grid_v2.py file is preserved for reference. To migrate:

1. Use main.py instead of dynamic_grid_v2.py
2. Update any custom scripts to use the new module imports
3. Configuration parameters remain the same
4. Database schema is unchanged

• Modular design has minimal performance overhead
• Database operations are optimized with proper indexing
• Memory usage is controlled with deque-based tick storage
• Async/await pattern for concurrent operations

• API keys are handled securely in live mode
• Database connections use parameterized queries
• Input validation prevents injection attacks
• No hardcoded credentials in source code

1. Multi-Exchange Support: Add Binance, Coinbase order managers
2. Advanced Indicators: RSI, MACD, Bollinger Bands
3. Machine Learning: Predictive models for regime detection
4. Web Interface: Real-time dashboard with WebSocket updates
5. Portfolio Management: Multi-asset grid strategies
6. Risk Management: Advanced position sizing and stop-loss mechanisms

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Ensure all tests pass
5. Submit a pull request with detailed description

This project is open source. See the original license terms in the monolithic file.