mcli-framework 7.1.1__py3-none-any.whl → 7.1.2__py3-none-any.whl

mcli/ml/tasks.py

@@ -1,10 +1,11 @@
 """Celery background tasks for ML system"""
 
+import asyncio
+from datetime import datetime, timedelta
+from typing import Any, Dict
+
 from celery import Celery, Task
 from celery.schedules import crontab
-from datetime import datetime, timedelta
-import asyncio
-from typing import Dict, Any
 
 from mcli.ml.config import settings
 from mcli.ml.logging import get_logger
@@ -13,18 +14,15 @@ logger = get_logger(__name__)
 
 # Create Celery app
 celery_app = Celery(
-    'mcli_ml',
-    broker=settings.redis.url,
-    backend=settings.redis.url,
-    include=['mcli.ml.tasks']
+    "mcli_ml", broker=settings.redis.url, backend=settings.redis.url, include=["mcli.ml.tasks"]
 )
 
 # Celery configuration
 celery_app.conf.update(
-    task_serializer='json',
-    accept_content=['json'],
-    result_serializer='json',
-    timezone='UTC',
+    task_serializer="json",
+    accept_content=["json"],
+    result_serializer="json",
+    timezone="UTC",
     enable_utc=True,
     task_track_started=True,
     task_time_limit=3600,  # 1 hour
@@ -35,29 +33,29 @@ celery_app.conf.update(
 
 # Schedule periodic tasks
 celery_app.conf.beat_schedule = {
-    'update-stock-data': {
-        'task': 'mcli.ml.tasks.update_stock_data_task',
-        'schedule': crontab(minute='*/15'),  # Every 15 minutes
+    "update-stock-data": {
+        "task": "mcli.ml.tasks.update_stock_data_task",
+        "schedule": crontab(minute="*/15"),  # Every 15 minutes
     },
-    'retrain-models': {
-        'task': 'mcli.ml.tasks.retrain_models_task',
-        'schedule': crontab(hour=2, minute=0),  # Daily at 2 AM
+    "retrain-models": {
+        "task": "mcli.ml.tasks.retrain_models_task",
+        "schedule": crontab(hour=2, minute=0),  # Daily at 2 AM
     },
-    'check-model-drift': {
-        'task': 'mcli.ml.tasks.check_model_drift_task',
-        'schedule': crontab(minute=0),  # Every hour
+    "check-model-drift": {
+        "task": "mcli.ml.tasks.check_model_drift_task",
+        "schedule": crontab(minute=0),  # Every hour
     },
-    'cleanup-old-predictions': {
-        'task': 'mcli.ml.tasks.cleanup_predictions_task',
-        'schedule': crontab(hour=3, minute=0),  # Daily at 3 AM
+    "cleanup-old-predictions": {
+        "task": "mcli.ml.tasks.cleanup_predictions_task",
+        "schedule": crontab(hour=3, minute=0),  # Daily at 3 AM
     },
-    'generate-daily-report': {
-        'task': 'mcli.ml.tasks.generate_daily_report_task',
-        'schedule': crontab(hour=6, minute=0),  # Daily at 6 AM
+    "generate-daily-report": {
+        "task": "mcli.ml.tasks.generate_daily_report_task",
+        "schedule": crontab(hour=6, minute=0),  # Daily at 6 AM
     },
-    'fetch-politician-trades': {
-        'task': 'mcli.ml.tasks.fetch_politician_trades_task',
-        'schedule': crontab(minute='*/30'),  # Every 30 minutes
+    "fetch-politician-trades": {
+        "task": "mcli.ml.tasks.fetch_politician_trades_task",
+        "schedule": crontab(minute="*/30"),  # Every 30 minutes
     },
 }
 
@@ -84,9 +82,9 @@ def train_model_task(self, model_id: str, retrain: bool = False) -> Dict[str, An
     try:
         logger.info(f"Starting training for model {model_id}")
 
-        from mcli.ml.mlops.pipeline_orchestrator import MLPipeline, PipelineConfig
-        from mcli.ml.database.session import SessionLocal
         from mcli.ml.database.models import Model, ModelStatus
+        from mcli.ml.database.session import SessionLocal
+        from mcli.ml.mlops.pipeline_orchestrator import MLPipeline, PipelineConfig
 
         # Get model from database
         db = SessionLocal()
@@ -100,10 +98,7 @@ def train_model_task(self, model_id: str, retrain: bool = False) -> Dict[str, An
         db.commit()
 
         # Configure and run pipeline
-        config = PipelineConfig(
-            experiment_name=f"model_{model_id}",
-            enable_mlflow=True
-        )
+        config = PipelineConfig(experiment_name=f"model_{model_id}", enable_mlflow=True)
 
         pipeline = MLPipeline(config)
 
@@ -114,9 +109,9 @@ def train_model_task(self, model_id: str, retrain: bool = False) -> Dict[str, An
 
         # Update model with results
         model.status = ModelStatus.TRAINED
-        model.train_accuracy = result.get('train_accuracy')
-        model.val_accuracy = result.get('val_accuracy')
-        model.test_accuracy = result.get('test_accuracy')
+        model.train_accuracy = result.get("train_accuracy")
+        model.val_accuracy = result.get("val_accuracy")
+        model.test_accuracy = result.get("test_accuracy")
         model.metrics = result
 
         db.commit()
@@ -137,8 +132,8 @@ def update_stock_data_task(self, ticker: str = None) -> Dict[str, Any]:
         logger.info(f"Updating stock data{f' for {ticker}' if ticker else ''}")
 
         from mcli.ml.data_ingestion.api_connectors import YahooFinanceConnector
-        from mcli.ml.database.session import SessionLocal
         from mcli.ml.database.models import StockData
+        from mcli.ml.database.session import SessionLocal
 
         connector = YahooFinanceConnector()
         db = SessionLocal()
@@ -162,9 +157,9 @@ def update_stock_data_task(self, ticker: str = None) -> Dict[str, Any]:
                     stock = StockData(ticker=ticker)
                     db.add(stock)
 
-                stock.current_price = data.get('price')
-                stock.volume = data.get('volume')
-                stock.change_1d = data.get('change_1d')
+                stock.current_price = data.get("price")
+                stock.volume = data.get("volume")
+                stock.change_1d = data.get("change_1d")
                 stock.last_updated = datetime.utcnow()
 
                 updated_count += 1
@@ -189,14 +184,12 @@ def check_model_drift_task() -> Dict[str, Any]:
     try:
         logger.info("Checking for model drift")
 
-        from mcli.ml.monitoring.drift_detection import ModelMonitor
-        from mcli.ml.database.session import SessionLocal
         from mcli.ml.database.models import Model, ModelStatus
+        from mcli.ml.database.session import SessionLocal
+        from mcli.ml.monitoring.drift_detection import ModelMonitor
 
         db = SessionLocal()
-        deployed_models = db.query(Model).filter(
-            Model.status == ModelStatus.DEPLOYED
-        ).all()
+        deployed_models = db.query(Model).filter(Model.status == ModelStatus.DEPLOYED).all()
 
         drift_detected = []
         for model in deployed_models:
@@ -212,7 +205,7 @@ def check_model_drift_task() -> Dict[str, Any]:
         return {
             "checked": len(deployed_models),
             "drift_detected": len(drift_detected),
-            "models_with_drift": drift_detected
+            "models_with_drift": drift_detected,
         }
 
     except Exception as e:
@@ -226,16 +219,14 @@ def cleanup_predictions_task() -> Dict[str, Any]:
     try:
         logger.info("Cleaning up old predictions")
 
-        from mcli.ml.database.session import SessionLocal
         from mcli.ml.database.models import Prediction
+        from mcli.ml.database.session import SessionLocal
 
         db = SessionLocal()
 
         # Delete predictions older than 90 days
         cutoff_date = datetime.utcnow() - timedelta(days=90)
-        deleted = db.query(Prediction).filter(
-            Prediction.created_at < cutoff_date
-        ).delete()
+        deleted = db.query(Prediction).filter(Prediction.created_at < cutoff_date).delete()
 
         db.commit()
         db.close()
@@ -254,16 +245,20 @@ def retrain_models_task() -> Dict[str, Any]:
     try:
         logger.info("Starting scheduled model retraining")
 
-        from mcli.ml.database.session import SessionLocal
         from mcli.ml.database.models import Model, ModelStatus
+        from mcli.ml.database.session import SessionLocal
 
         db = SessionLocal()
 
         # Get models that need retraining
-        models_to_retrain = db.query(Model).filter(
-            Model.status == ModelStatus.DEPLOYED,
-            Model.updated_at < datetime.utcnow() - timedelta(days=7)
-        ).all()
+        models_to_retrain = (
+            db.query(Model)
+            .filter(
+                Model.status == ModelStatus.DEPLOYED,
+                Model.updated_at < datetime.utcnow() - timedelta(days=7),
+            )
+            .all()
+        )
 
         retrained = []
         for model in models_to_retrain:
@@ -287,23 +282,25 @@ def generate_daily_report_task() -> Dict[str, Any]:
     try:
         logger.info("Generating daily report")
 
+        from mcli.ml.database.models import Portfolio, Prediction, User
         from mcli.ml.database.session import SessionLocal
-        from mcli.ml.database.models import Prediction, Portfolio, User
 
         db = SessionLocal()
 
         # Gather statistics
-        total_predictions = db.query(Prediction).filter(
-            Prediction.prediction_date >= datetime.utcnow() - timedelta(days=1)
-        ).count()
+        total_predictions = (
+            db.query(Prediction)
+            .filter(Prediction.prediction_date >= datetime.utcnow() - timedelta(days=1))
+            .count()
+        )
 
-        active_portfolios = db.query(Portfolio).filter(
-            Portfolio.is_active == True
-        ).count()
+        active_portfolios = db.query(Portfolio).filter(Portfolio.is_active == True).count()
 
-        active_users = db.query(User).filter(
-            User.last_login_at >= datetime.utcnow() - timedelta(days=1)
-        ).count()
+        active_users = (
+            db.query(User)
+            .filter(User.last_login_at >= datetime.utcnow() - timedelta(days=1))
+            .count()
+        )
 
         db.close()
 
@@ -312,7 +309,7 @@ def generate_daily_report_task() -> Dict[str, Any]:
             "predictions_24h": total_predictions,
             "active_portfolios": active_portfolios,
             "active_users_24h": active_users,
-            "generated_at": datetime.utcnow().isoformat()
+            "generated_at": datetime.utcnow().isoformat(),
         }
 
         # In real implementation, send email or save to storage
@@ -332,8 +329,8 @@ def fetch_politician_trades_task() -> Dict[str, Any]:
         logger.info("Fetching politician trades")
 
         from mcli.ml.data_ingestion.api_connectors import CongressionalTradingConnector
+        from mcli.ml.database.models import Politician, Trade
         from mcli.ml.database.session import SessionLocal
-        from mcli.ml.database.models import Trade, Politician
 
         connector = CongressionalTradingConnector()
         db = SessionLocal()
@@ -344,11 +341,15 @@ def fetch_politician_trades_task() -> Dict[str, Any]:
         new_trades = 0
         for trade_info in trades_data:
             # Check if trade exists
-            existing = db.query(Trade).filter(
-                Trade.politician_id == trade_info['politician_id'],
-                Trade.ticker == trade_info['ticker'],
-                Trade.disclosure_date == trade_info['disclosure_date']
-            ).first()
+            existing = (
+                db.query(Trade)
+                .filter(
+                    Trade.politician_id == trade_info["politician_id"],
+                    Trade.ticker == trade_info["ticker"],
+                    Trade.disclosure_date == trade_info["disclosure_date"],
+                )
+                .first()
+            )
 
             if not existing:
                 trade = Trade(**trade_info)
@@ -372,18 +373,16 @@ def process_batch_predictions_task(self, predictions: list) -> Dict[str, Any]:
     try:
         logger.info(f"Processing batch of {len(predictions)} predictions")
 
-        from mcli.ml.models import get_model_by_id
         import numpy as np
 
+        from mcli.ml.models import get_model_by_id
+
         results = []
         for pred in predictions:
-            model = asyncio.run(get_model_by_id(pred['model_id']))
-            features = np.array(pred['features']).reshape(1, -1)
+            model = asyncio.run(get_model_by_id(pred["model_id"]))
+            features = np.array(pred["features"]).reshape(1, -1)
             result = model.predict(features)
-            results.append({
-                'ticker': pred['ticker'],
-                'prediction': float(result[0])
-            })
+            results.append({"ticker": pred["ticker"], "prediction": float(result[0])})
 
         logger.info(f"Batch predictions completed")
         return {"predictions": results}
@@ -394,7 +393,7 @@ def process_batch_predictions_task(self, predictions: list) -> Dict[str, Any]:
 
 
 # Worker health check
-@celery_app.task(name='health_check')
+@celery_app.task(name="health_check")
 def health_check():
     """Health check for Celery worker"""
-    return {"status": "healthy", "timestamp": datetime.utcnow().isoformat()}
+    return {"status": "healthy", "timestamp": datetime.utcnow().isoformat()}

mcli/ml/tests/test_integration.py

@@ -1,28 +1,30 @@
 """Integration tests for the complete ML pipeline"""
 
-import sys
 import os
+import sys
+
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
 
-import pytest
-import pandas as pd
-import numpy as np
-from datetime import datetime, timedelta
+import logging
 import tempfile
+from datetime import datetime, timedelta
 from pathlib import Path
-import logging
 
-# Import all components
-from ml.preprocessing.data_processor import DataProcessor, ProcessingConfig
-from ml.features.stock_features import StockRecommendationFeatures
-from ml.features.political_features import PoliticalInfluenceFeatures
+import numpy as np
+import pandas as pd
+import pytest
+from ml.backtesting.backtest_engine import BacktestConfig, BacktestEngine, TradingStrategy
+from ml.backtesting.performance_metrics import PerformanceAnalyzer
 from ml.features.ensemble_features import EnsembleFeatureBuilder
-from ml.models.ensemble_models import DeepEnsembleModel, EnsembleConfig, ModelConfig
-from ml.models.recommendation_models import StockRecommendationModel, RecommendationConfig
-from ml.mlops.pipeline_orchestrator import MLPipeline, PipelineConfig, PipelineExecutor
+from ml.features.political_features import PoliticalInfluenceFeatures
+from ml.features.stock_features import StockRecommendationFeatures
 from ml.mlops.experiment_tracker import ExperimentTracker, MLflowConfig, ModelRegistry
-from ml.backtesting.backtest_engine import BacktestEngine, BacktestConfig, TradingStrategy
-from ml.backtesting.performance_metrics import PerformanceAnalyzer
+from ml.mlops.pipeline_orchestrator import MLPipeline, PipelineConfig, PipelineExecutor
+from ml.models.ensemble_models import DeepEnsembleModel, EnsembleConfig, ModelConfig
+from ml.models.recommendation_models import RecommendationConfig, StockRecommendationModel
+
+# Import all components
+from ml.preprocessing.data_processor import DataProcessor, ProcessingConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -44,7 +46,7 @@ class TestDataIntegration:
         # Process data
         processed_trading = processor.process_politician_trades(trading_data)
         assert len(processed_trading) > 0
-        assert 'transaction_amount_cleaned' in processed_trading.columns
+        assert "transaction_amount_cleaned" in processed_trading.columns
 
         # Clean data
         cleaned_data = processor.clean_data(processed_trading)
@@ -67,7 +69,7 @@ class TestDataIntegration:
 
         # Political features
         political_features = political_extractor.extract_influence_features(trading_data)
-        assert 'total_influence' in political_features.columns
+        assert "total_influence" in political_features.columns
 
         # Ensemble features
         combined = pd.concat([political_features, stock_features], axis=1)
@@ -79,34 +81,39 @@ class TestDataIntegration:
         n_records = 100
         data = []
         for _ in range(n_records):
-            data.append({
-                'politician_name_cleaned': np.random.choice(['Pelosi', 'McConnell']),
-                'transaction_date_cleaned': datetime.now() - timedelta(days=np.random.randint(1, 365)),
-                'transaction_amount_cleaned': np.random.uniform(1000, 500000),
-                'transaction_type_cleaned': np.random.choice(['buy', 'sell']),
-                'ticker_cleaned': np.random.choice(['AAPL', 'MSFT', 'GOOGL'])
-            })
+            data.append(
+                {
+                    "politician_name_cleaned": np.random.choice(["Pelosi", "McConnell"]),
+                    "transaction_date_cleaned": datetime.now()
+                    - timedelta(days=np.random.randint(1, 365)),
+                    "transaction_amount_cleaned": np.random.uniform(1000, 500000),
+                    "transaction_type_cleaned": np.random.choice(["buy", "sell"]),
+                    "ticker_cleaned": np.random.choice(["AAPL", "MSFT", "GOOGL"]),
+                }
+            )
         return pd.DataFrame(data)
 
     def _generate_mock_stock_data(self):
         """Generate mock stock data"""
         dates = pd.date_range(end=datetime.now(), periods=100)
-        tickers = ['AAPL', 'MSFT', 'GOOGL']
+        tickers = ["AAPL", "MSFT", "GOOGL"]
         data = []
 
         for ticker in tickers:
             base_price = np.random.uniform(100, 300)
             for date in dates:
                 price = base_price * (1 + np.random.normal(0, 0.02))
-                data.append({
-                    'symbol': ticker,
-                    'date': date,
-                    'close': price,
-                    'volume': np.random.randint(1000000, 10000000),
-                    'open': price * 0.99,
-                    'high': price * 1.01,
-                    'low': price * 0.98
-                })
+                data.append(
+                    {
+                        "symbol": ticker,
+                        "date": date,
+                        "close": price,
+                        "volume": np.random.randint(1000000, 10000000),
+                        "open": price * 0.99,
+                        "high": price * 1.01,
+                        "low": price * 0.98,
+                    }
+                )
 
         return pd.DataFrame(data)
 
@@ -131,7 +138,7 @@ class TestModelIntegration:
                 learning_rate=0.001,
                 weight_decay=1e-4,
                 batch_size=32,
-                epochs=2
+                epochs=2,
             )
         ]
 
@@ -155,8 +162,7 @@ class TestModelIntegration:
 
         # Create request
         request = PredictionRequest(
-            trading_data={'politician': 'Test', 'amount': 10000},
-            tickers=['AAPL', 'MSFT']
+            trading_data={"politician": "Test", "amount": 10000}, tickers=["AAPL", "MSFT"]
         )
 
         # Generate prediction (async would need event loop)
@@ -176,7 +182,7 @@ class TestPipelineIntegration:
                 data_dir=Path(tmpdir) / "data",
                 model_dir=Path(tmpdir) / "models",
                 output_dir=Path(tmpdir) / "outputs",
-                enable_mlflow=False  # Disable for testing
+                enable_mlflow=False,  # Disable for testing
             )
 
             # Create pipeline
@@ -185,16 +191,15 @@ class TestPipelineIntegration:
             # Run pipeline (with mock data)
             result = pipeline.run()
 
-            assert 'model' in result
-            assert result['model'] is not None
+            assert "model" in result
+            assert result["model"] is not None
 
     def test_pipeline_with_mlflow(self):
         """Test pipeline with MLflow tracking"""
         with tempfile.TemporaryDirectory() as tmpdir:
             # Configure MLflow
             mlflow_config = MLflowConfig(
-                tracking_uri=f"sqlite:///{tmpdir}/mlflow.db",
-                experiment_name="test_experiment"
+                tracking_uri=f"sqlite:///{tmpdir}/mlflow.db", experiment_name="test_experiment"
             )
 
             # Configure pipeline
@@ -202,7 +207,7 @@ class TestPipelineIntegration:
                 data_dir=Path(tmpdir) / "data",
                 model_dir=Path(tmpdir) / "models",
                 enable_mlflow=True,
-                mlflow_config=mlflow_config
+                mlflow_config=mlflow_config,
             )
 
             # Create and run pipeline
@@ -223,16 +228,18 @@ class TestBacktestIntegration:
         dates = pd.date_range(end=datetime.now(), periods=252)
         price_data = []
 
-        for ticker in ['AAPL', 'MSFT', 'GOOGL', 'SPY']:
+        for ticker in ["AAPL", "MSFT", "GOOGL", "SPY"]:
             base_price = np.random.uniform(100, 300)
             for date in dates:
                 price = base_price * (1 + np.random.normal(0, 0.02))
-                price_data.append({
-                    'symbol': ticker,
-                    'date': date,
-                    'close': price,
-                    'volume': np.random.randint(1000000, 10000000)
-                })
+                price_data.append(
+                    {
+                        "symbol": ticker,
+                        "date": date,
+                        "close": price,
+                        "volume": np.random.randint(1000000, 10000000),
+                    }
+                )
 
         price_df = pd.DataFrame(price_data)
 
@@ -242,7 +249,7 @@ class TestBacktestIntegration:
             commission=0.001,
             slippage=0.001,
             max_positions=10,
-            benchmark='SPY'
+            benchmark="SPY",
         )
 
         # Create engine and strategy
@@ -255,7 +262,7 @@ class TestBacktestIntegration:
 
         assert result is not None
         assert len(result.portfolio_value) > 0
-        assert result.metrics['total_return'] is not None
+        assert result.metrics["total_return"] is not None
 
     def test_performance_analysis(self):
         """Test performance analysis"""
@@ -265,9 +272,7 @@ class TestBacktestIntegration:
 
         # Analyze performance
         analyzer = PerformanceAnalyzer()
-        portfolio_metrics, risk_metrics = analyzer.calculate_metrics(
-            returns, benchmark_returns
-        )
+        portfolio_metrics, risk_metrics = analyzer.calculate_metrics(returns, benchmark_returns)
 
         assert portfolio_metrics.sharpe_ratio is not None
         assert risk_metrics.value_at_risk_95 is not None
@@ -310,7 +315,7 @@ class TestSystemIntegration:
                     learning_rate=0.001,
                     weight_decay=1e-4,
                     batch_size=32,
-                    epochs=1
+                    epochs=1,
                 )
             ]
 
@@ -326,7 +331,7 @@ class TestSystemIntegration:
             engine.set_strategy(strategy)
 
             result = engine.run(stock_data)
-            assert result.metrics['total_return'] is not None
+            assert result.metrics["total_return"] is not None
 
             # Step 5: Performance Analysis
             logger.info("Step 5: Analyzing performance...")
@@ -344,21 +349,24 @@ class TestSystemIntegration:
         data = []
 
         for _ in range(n_records):
-            data.append({
-                'politician_name_cleaned': np.random.choice(['Pelosi', 'McConnell', 'Schumer']),
-                'transaction_date_cleaned': datetime.now() - timedelta(days=np.random.randint(1, 365)),
-                'transaction_amount_cleaned': np.random.uniform(1000, 1000000),
-                'transaction_type_cleaned': np.random.choice(['buy', 'sell']),
-                'ticker_cleaned': np.random.choice(['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']),
-                'disclosure_date': datetime.now() - timedelta(days=np.random.randint(0, 45))
-            })
+            data.append(
+                {
+                    "politician_name_cleaned": np.random.choice(["Pelosi", "McConnell", "Schumer"]),
+                    "transaction_date_cleaned": datetime.now()
+                    - timedelta(days=np.random.randint(1, 365)),
+                    "transaction_amount_cleaned": np.random.uniform(1000, 1000000),
+                    "transaction_type_cleaned": np.random.choice(["buy", "sell"]),
+                    "ticker_cleaned": np.random.choice(["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]),
+                    "disclosure_date": datetime.now() - timedelta(days=np.random.randint(0, 45)),
+                }
+            )
 
         return pd.DataFrame(data)
 
     def _generate_stock_data(self):
         """Generate comprehensive stock data"""
         dates = pd.date_range(end=datetime.now(), periods=365)
-        tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'SPY']
+        tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA", "SPY"]
         data = []
 
         for ticker in tickers:
@@ -371,15 +379,17 @@ class TestSystemIntegration:
                 new_price = prices[-1] * (1 + change)
                 prices.append(new_price)
 
-                data.append({
-                    'symbol': ticker,
-                    'date': date,
-                    'close': new_price,
-                    'open': new_price * (1 + np.random.normal(0, 0.005)),
-                    'high': new_price * (1 + abs(np.random.normal(0, 0.01))),
-                    'low': new_price * (1 - abs(np.random.normal(0, 0.01))),
-                    'volume': np.random.randint(1000000, 50000000)
-                })
+                data.append(
+                    {
+                        "symbol": ticker,
+                        "date": date,
+                        "close": new_price,
+                        "open": new_price * (1 + np.random.normal(0, 0.005)),
+                        "high": new_price * (1 + abs(np.random.normal(0, 0.01))),
+                        "low": new_price * (1 - abs(np.random.normal(0, 0.01))),
+                        "volume": np.random.randint(1000000, 50000000),
+                    }
+                )
 
         return pd.DataFrame(data)
 
@@ -426,4 +436,4 @@ if __name__ == "__main__":
     system_tests.test_complete_workflow()
     logger.info("✅ System integration tests passed")
 
-    logger.info("🎉 All integration tests passed successfully!")
+    logger.info("🎉 All integration tests passed successfully!")