MEXC INTEGRATION WORKS!!!

core/trading_executor.py

@@ -267,6 +267,38 @@ class TradingExecutor:
                 logger.error(f"Error executing {action} signal for {symbol}: {e}")
                 return False
     
+    def _cancel_open_orders(self, symbol: str) -> bool:
+        """Cancel all open orders for a symbol before placing new orders"""
+        try:
+            logger.info(f"Checking for open orders to cancel for {symbol}")
+            open_orders = self.exchange.get_open_orders(symbol)
+            
+            if open_orders and len(open_orders) > 0:
+                logger.info(f"Found {len(open_orders)} open orders for {symbol}, cancelling...")
+                
+                for order in open_orders:
+                    order_id = order.get('orderId')
+                    if order_id:
+                        try:
+                            cancel_result = self.exchange.cancel_order(symbol, str(order_id))
+                            if cancel_result:
+                                logger.info(f"Successfully cancelled order {order_id} for {symbol}")
+                            else:
+                                logger.warning(f"Failed to cancel order {order_id} for {symbol}")
+                        except Exception as e:
+                            logger.error(f"Error cancelling order {order_id}: {e}")
+                
+                # Wait a moment for cancellations to process
+                time.sleep(0.5)
+                return True
+            else:
+                logger.debug(f"No open orders found for {symbol}")
+                return True
+                
+        except Exception as e:
+            logger.error(f"Error checking/cancelling open orders for {symbol}: {e}")
+            return False
+    
     def _check_safety_conditions(self, symbol: str, action: str) -> bool:
         """Check if it's safe to execute a trade"""
         # Check if trading is stopped
@@ -292,12 +324,21 @@ class TradingExecutor:
         #     logger.warning(f"Daily trade limit reached: {self.daily_trades}")
         #     return False
         
-        # Check trade interval
+        # Check trade interval - allow bypass for test scenarios
         min_interval = self.mexc_config.get('min_trade_interval_seconds', 5)
         last_trade = self.last_trade_time.get(symbol, datetime.min)
-        if (datetime.now() - last_trade).total_seconds() < min_interval:
-            logger.info(f"Trade interval not met for {symbol}")
-            return False
+        time_since_last = (datetime.now() - last_trade).total_seconds()
+        
+        # Allow bypass for high confidence sells (closing positions) or test scenarios
+        if time_since_last < min_interval:
+            # Allow immediate sells for closing positions or very high confidence (0.9+)
+            if action == 'SELL' and symbol in self.positions:
+                logger.info(f"Allowing immediate SELL to close position for {symbol}")
+            elif hasattr(self, '_test_mode') and self._test_mode:
+                logger.info(f"Test mode: bypassing trade interval for {symbol}")
+            else:
+                logger.info(f"Trade interval not met for {symbol} ({time_since_last:.1f}s < {min_interval}s)")
+                return False
         
         # Check concurrent positions
         max_positions = self.mexc_config.get('max_concurrent_positions', 1)
@@ -319,6 +360,10 @@ class TradingExecutor:
                 logger.info(f"Already have LONG position in {symbol}")
                 return False
         
+        # Cancel any existing open orders before placing new order
+        if not self.simulation_mode:
+            self._cancel_open_orders(symbol)
+        
         # Calculate position size
         position_value = self._calculate_position_size(confidence, current_price)
         quantity = position_value / current_price
@@ -412,6 +457,10 @@ class TradingExecutor:
         
         position = self.positions[symbol]
         
+        # Cancel any existing open orders before placing new order
+        if not self.simulation_mode:
+            self._cancel_open_orders(symbol)
+        
         logger.info(f"Executing SELL: {position.quantity:.6f} {symbol} at ${current_price:.2f} "
                    f"(confidence: {confidence:.2f}) [{'SIMULATION' if self.simulation_mode else 'LIVE'}]")
         
@@ -1344,4 +1393,12 @@ class TradingExecutor:
                     'max_percent': 20.0,
                     'min_percent': 2.0
                 }
-            }
+            }
+
+    def set_test_mode(self, enabled: bool = True):
+        """Enable test mode to bypass safety checks for testing"""
+        self._test_mode = enabled
+        if enabled:
+            logger.info("TRADING EXECUTOR: Test mode enabled - bypassing safety checks")
+        else:
+            logger.info("TRADING EXECUTOR: Test mode disabled - normal safety checks active")