276 lines
9.3 KiB
Python
276 lines
9.3 KiB
Python
"""
|
|
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()) |