wip

ANNOTATE/web/app.py

@@ -2626,6 +2626,95 @@ class AnnotationDashboard:
                     'error': str(e)
                 })
         
+        @self.server.route('/api/live-updates-batch', methods=['POST'])
+        def get_live_updates_batch():
+            """Get live chart and prediction updates for multiple timeframes (optimized batch endpoint)"""
+            try:
+                data = request.get_json() or {}
+                symbol = data.get('symbol', 'ETH/USDT')
+                timeframes = data.get('timeframes', ['1m'])
+                
+                response = {
+                    'success': True,
+                    'chart_updates': {},  # Dict of timeframe -> chart_update
+                    'prediction': None     # Single prediction for all timeframes
+                }
+                
+                # Get latest candle for each requested timeframe
+                if self.data_loader:
+                    for timeframe in timeframes:
+                        try:
+                            df = self.data_loader.get_data(symbol, timeframe, limit=2, direction='latest')
+                            if df is not None and not df.empty:
+                                latest_candle = df.iloc[-1]
+                                
+                                # Format timestamp as ISO string
+                                timestamp = latest_candle.name
+                                if hasattr(timestamp, 'isoformat'):
+                                    if timestamp.tzinfo is not None:
+                                        timestamp_str = timestamp.astimezone(timezone.utc).isoformat()
+                                    else:
+                                        timestamp_str = timestamp.isoformat() + 'Z'
+                                else:
+                                    timestamp_str = str(timestamp)
+                                
+                                is_confirmed = len(df) >= 2
+                                
+                                response['chart_updates'][timeframe] = {
+                                    'symbol': symbol,
+                                    'timeframe': timeframe,
+                                    'candle': {
+                                        'timestamp': timestamp_str,
+                                        'open': float(latest_candle['open']),
+                                        'high': float(latest_candle['high']),
+                                        'low': float(latest_candle['low']),
+                                        'close': float(latest_candle['close']),
+                                        'volume': float(latest_candle['volume'])
+                                    },
+                                    'is_confirmed': is_confirmed
+                                }
+                        except Exception as e:
+                            logger.debug(f"Error getting candle for {timeframe}: {e}")
+                
+                # Get latest model predictions (same for all timeframes)
+                if self.orchestrator:
+                    try:
+                        predictions = {}
+                        
+                        # DQN predictions
+                        if hasattr(self.orchestrator, 'recent_dqn_predictions') and symbol in self.orchestrator.recent_dqn_predictions:
+                            dqn_preds = list(self.orchestrator.recent_dqn_predictions[symbol])
+                            if dqn_preds:
+                                predictions['dqn'] = dqn_preds[-1]
+                        
+                        # CNN predictions
+                        if hasattr(self.orchestrator, 'recent_cnn_predictions') and symbol in self.orchestrator.recent_cnn_predictions:
+                            cnn_preds = list(self.orchestrator.recent_cnn_predictions[symbol])
+                            if cnn_preds:
+                                predictions['cnn'] = cnn_preds[-1]
+                        
+                        # Transformer predictions
+                        if hasattr(self.orchestrator, 'recent_transformer_predictions') and symbol in self.orchestrator.recent_transformer_predictions:
+                            transformer_preds = list(self.orchestrator.recent_transformer_predictions[symbol])
+                            if transformer_preds:
+                                transformer_pred = transformer_preds[-1].copy()
+                                predictions['transformer'] = self._serialize_prediction(transformer_pred)
+                        
+                        if predictions:
+                            response['prediction'] = predictions
+                            
+                    except Exception as e:
+                        logger.debug(f"Error getting predictions: {e}")
+                
+                return jsonify(response)
+                
+            except Exception as e:
+                logger.error(f"Error in batch live updates: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e)
+                })
+        
         @self.server.route('/api/realtime-inference/signals', methods=['GET'])
         def get_realtime_signals():
             """Get latest real-time inference signals"""