""" Example showing how to integrate COBY system with existing orchestrator. Demonstrates drop-in replacement and mode switching capabilities. """ import asyncio import logging from datetime import datetime, timedelta # Import the COBY data provider replacement from ..integration.data_provider_replacement import COBYDataProvider from ..integration.orchestrator_adapter import MarketTick # Set up logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) async def demonstrate_basic_usage(): """Demonstrate basic COBY data provider usage.""" logger.info("=== Basic COBY Data Provider Usage ===") # Initialize COBY data provider (drop-in replacement) data_provider = COBYDataProvider() try: # Test basic data access methods logger.info("Testing basic data access...") # Get current price current_price = data_provider.get_current_price('BTCUSDT') logger.info(f"Current BTC price: ${current_price}") # Get historical data historical_data = data_provider.get_historical_data('BTCUSDT', '1m', limit=10) if historical_data is not None: logger.info(f"Historical data shape: {historical_data.shape}") logger.info(f"Latest close price: ${historical_data['close'].iloc[-1]}") # Get COB data cob_data = data_provider.get_latest_cob_data('BTCUSDT') if cob_data: logger.info(f"Latest COB data: {cob_data}") # Get data quality indicators quality = data_provider.adapter.get_data_quality_indicators('BTCUSDT') logger.info(f"Data quality score: {quality.get('quality_score', 0)}") except Exception as e: logger.error(f"Error in basic usage: {e}") finally: await data_provider.close() async def demonstrate_subscription_system(): """Demonstrate the subscription system.""" logger.info("=== COBY Subscription System ===") data_provider = COBYDataProvider() try: # Set up tick subscription tick_count = 0 def tick_callback(tick: MarketTick): nonlocal tick_count tick_count += 1 logger.info(f"Received tick #{tick_count}: {tick.symbol} @ ${tick.price}") # Subscribe to ticks subscriber_id = data_provider.subscribe_to_ticks( tick_callback, symbols=['BTCUSDT', 'ETHUSDT'], subscriber_name='example_subscriber' ) logger.info(f"Subscribed to ticks with ID: {subscriber_id}") # Set up COB data subscription cob_count = 0 def cob_callback(symbol: str, data: dict): nonlocal cob_count cob_count += 1 logger.info(f"Received COB data #{cob_count} for {symbol}") cob_subscriber_id = data_provider.subscribe_to_cob_raw_ticks(cob_callback) logger.info(f"Subscribed to COB data with ID: {cob_subscriber_id}") # Wait for some data logger.info("Waiting for data updates...") await asyncio.sleep(10) # Unsubscribe data_provider.unsubscribe(subscriber_id) data_provider.unsubscribe(cob_subscriber_id) logger.info("Unsubscribed from all feeds") except Exception as e: logger.error(f"Error in subscription demo: {e}") finally: await data_provider.close() async def demonstrate_mode_switching(): """Demonstrate switching between live and replay modes.""" logger.info("=== COBY Mode Switching ===") data_provider = COBYDataProvider() try: # Start in live mode current_mode = data_provider.get_current_mode() logger.info(f"Current mode: {current_mode}") # Get some live data live_price = data_provider.get_current_price('BTCUSDT') logger.info(f"Live price: ${live_price}") # Switch to replay mode logger.info("Switching to replay mode...") start_time = datetime.utcnow() - timedelta(hours=1) end_time = datetime.utcnow() - timedelta(minutes=30) success = await data_provider.switch_to_replay_mode( start_time=start_time, end_time=end_time, speed=10.0, # 10x speed symbols=['BTCUSDT'] ) if success: logger.info("Successfully switched to replay mode") # Get replay status replay_status = data_provider.get_replay_status() if replay_status: logger.info(f"Replay progress: {replay_status['progress']:.2%}") logger.info(f"Replay speed: {replay_status['speed']}x") # Wait for some replay data await asyncio.sleep(5) # Get data during replay replay_price = data_provider.get_current_price('BTCUSDT') logger.info(f"Replay price: ${replay_price}") # Switch back to live mode logger.info("Switching back to live mode...") success = await data_provider.switch_to_live_mode() if success: logger.info("Successfully switched back to live mode") current_mode = data_provider.get_current_mode() logger.info(f"Current mode: {current_mode}") except Exception as e: logger.error(f"Error in mode switching demo: {e}") finally: await data_provider.close() async def demonstrate_orchestrator_compatibility(): """Demonstrate compatibility with orchestrator interface.""" logger.info("=== Orchestrator Compatibility ===") data_provider = COBYDataProvider() try: # Test methods that orchestrator uses logger.info("Testing orchestrator-compatible methods...") # Build base data input (used by ML models) base_data = data_provider.build_base_data_input('BTCUSDT') if base_data: features = base_data.get_feature_vector() logger.info(f"Feature vector shape: {features.shape}") # Get feature matrix (used by ML models) feature_matrix = data_provider.get_feature_matrix( 'BTCUSDT', timeframes=['1m', '5m'], window_size=20 ) if feature_matrix is not None: logger.info(f"Feature matrix shape: {feature_matrix.shape}") # Get pivot bounds (used for normalization) pivot_bounds = data_provider.get_pivot_bounds('BTCUSDT') if pivot_bounds: logger.info(f"Price range: ${pivot_bounds.price_min:.2f} - ${pivot_bounds.price_max:.2f}") # Get COB imbalance (used for market microstructure analysis) imbalance = data_provider.get_current_cob_imbalance('BTCUSDT') logger.info(f"Order book imbalance: {imbalance['imbalance']:.3f}") # Get system status status = data_provider.get_cached_data_summary() logger.info(f"System status: {status}") # Test compatibility methods data_provider.start_centralized_data_collection() data_provider.invalidate_ohlcv_cache('BTCUSDT') logger.info("All orchestrator compatibility tests passed!") except Exception as e: logger.error(f"Error in compatibility demo: {e}") finally: await data_provider.close() async def demonstrate_performance_monitoring(): """Demonstrate performance monitoring capabilities.""" logger.info("=== Performance Monitoring ===") data_provider = COBYDataProvider() try: # Get initial statistics initial_stats = data_provider.get_subscriber_stats() logger.info(f"Initial stats: {initial_stats}") # Get data quality information quality_info = data_provider.get_cob_data_quality() logger.info(f"Data quality info: {quality_info}") # Get WebSocket status ws_status = data_provider.get_cob_websocket_status() logger.info(f"WebSocket status: {ws_status}") # Monitor system metadata system_metadata = data_provider.adapter.get_system_metadata() logger.info(f"System components health: {system_metadata['components']}") logger.info(f"Active subscribers: {system_metadata['active_subscribers']}") except Exception as e: logger.error(f"Error in performance monitoring: {e}") finally: await data_provider.close() async def main(): """Run all demonstration examples.""" logger.info("Starting COBY Integration Examples...") try: # Run all demonstrations await demonstrate_basic_usage() await asyncio.sleep(1) await demonstrate_subscription_system() await asyncio.sleep(1) await demonstrate_mode_switching() await asyncio.sleep(1) await demonstrate_orchestrator_compatibility() await asyncio.sleep(1) await demonstrate_performance_monitoring() logger.info("All COBY integration examples completed successfully!") except Exception as e: logger.error(f"Error running examples: {e}") if __name__ == "__main__": # Run the examples asyncio.run(main())