Claude/analyze maintainability 01 hs9 se wv5 usatg mz a2kzaag

[chpeu]

PR Type

Enhancement, Tests

---

Description

• Major ML Integration: Implemented HistGradientBoosting ML model with auto-calibration system for dynamic confidence adjustment in trade validation

• ATR-Based TP/SL System: Migrated from FIXE mode to ATR-based HYBRID INTELLIGENT mode with dynamic volatility adaptation and stagnation exit (time decay)

• Advanced Filters: Added OPT 3 #14-19 filters including anti-whipsaw, retest confirmation, cooldown, candle close, and momentum continuity

• Real-time SL Verification: Implemented WebSocket-based Stop Loss verification with delayed SL order placement via setup_realtime_sl_check() and schedule_sl_order_placement()

• Adaptive Sizing System: Position size adjustment based on real-time win rate per pair/session with configurable multipliers

• BYPASS MODE for MEXC Futures: Added browser token authentication to circumvent API blocking with dual-mode operation (BYPASS and CCXT) and intelligent fallback

• Circuit Breaker Pattern: Automatic trading halt after consecutive failures with configurable thresholds and Telegram notifications

• Enhanced Shadow Trading: Realistic order book walking, slippage calculation, and network latency modeling

• ML Router Refactoring: Reduced from 2522 to 80 lines with modular architecture and legacy support

• CatBoost Trainer: New ML trainer implementation as alternative to XGBoost with better categorical feature handling

• Diagnostic Tools: Added ML pipeline diagnostic script and configuration analysis utilities for troubleshooting

• Improved Error Handling: Specific exception types and circuit breaker logic for position close failures

• Enhanced Position Updates: Additional fields including ml_confidence, adaptive_sizing_multiplier, tp_sl_mode, opened_at, leverage_used

---

Diagram Walkthrough

flowchart LR
  A["Trading Config"] -->|"ATR-based TP/SL"| B["Position Manager"]
  C["ML Model<br/>HistGradientBoosting"] -->|"Confidence Score"| B
  B -->|"Real-time SL Check"| D["WebSocket Manager"]
  E["Scanner"] -->|"Opportunities"| C
  E -->|"Advanced Filters"| F["Trade Validation"]
  F -->|"Adaptive Sizing"| B
  B -->|"BYPASS/CCXT"| G["MEXC Futures"]
  G -->|"Circuit Breaker"| H["Trading Halt"]
  I["ML Auto-Calibration"] -->|"Recalibrate"| C

Loading

File Walkthrough

	Relevant files
Enhancement	5 files main.py Major refactoring with ML integration, SL fixes, and enhanced error handling main.py Added comprehensive type hints and docstrings to major functions (global_exception_handler, scanner_loop_callback, position_check_loop_callback, init_instances, etc.) Implemented real-time SL (Stop Loss) verification via WebSocket with setup_realtime_sl_check() and delayed SL order placement via schedule_sl_order_placement() Added GradientBoosting ML filter integration with confidence scoring and model predictions for trade validation Enhanced error handling with specific exception types (ImportError, OSError, IOError, ConnectionError) and circuit breaker logic for position close failures Added adaptive sizing multiplier support, ML calibration auto-seeding, and configuration export functions (_organize_trading_config_for_export, _flatten_trading_config_for_excel) Integrated new utility function get_preferred_price() for consistent price extraction across different data formats Added support for OPT 3 #14-19 advanced filters (anti-whipsaw, retest confirmation, cooldown, candle close, momentum continuity) Enhanced WebSocket manager injection and notification manager integration for scanner and position check callbacks Added dynamic trailing stop configuration reload and ML calibration parameters (decay days, min trades, bucket size) Improved position update emissions with additional fields (ml_confidence, adaptive_sizing_multiplier, tp_sl_mode, opened_at, leverage_used) +1602/-246 catboost_trainer.py New CatBoost ML trainer implementation for trading              optimization/models/catboost_trainer.py New file implementing CatBoost ML trainer for trading predictions Provides alternative to XGBoost with better handling of categorical features and smaller datasets Includes training pipeline with automatic class balancing and early stopping Generates model metadata with feature names and categorical feature tracking Supports configurable hyperparameters (iterations, learning_rate, depth, l2_leaf_reg) +157/-0  live_order_manager_futures.py BYPASS MODE, Circuit Breaker, and Shadow Trading Implementation trading/live_order_manager_futures.py Added comprehensive BYPASS MODE support for MEXC Futures with browser token authentication to circumvent API blocking Implemented Circuit Breaker pattern for automatic trading halt after consecutive failures with configurable thresholds Enhanced shadow trading simulation with realistic order book walking, slippage calculation, and network latency modeling Added dual-mode operation (BYPASS and CCXT) with intelligent fallback, rate limiting, and position size verification Implemented contract size conversion fixes for proper token/contract calculations across different MEXC pairs Added Telegram notifications for critical events (circuit breaker, silent rejections, errors) Enhanced close_position with forced full-close detection for partial TP when volume rounds to zero +1749/-142 ml.py ML Router Refactoring: Modular Architecture with Legacy Support api/routes/ml.py Massive refactoring: reduced from 2522 to 80 lines by extracting routes into modular files Main router now aggregates sub-routers (ml_tasks, ml_dashboard, ml_predictions, ml_models, ml_legacy) Re-exports common utilities and legacy functions for backward compatibility with tests Implements Phase 4-5 migration strategy with 22 routes migrated and 22 legacy routes remaining +70/-2512 scanner_ml_integration.py ML Integration: Switch to Optimized GradientBoosting Model optimization/scanner_ml_integration.py Updated get_ml_prediction_for_opportunity() to use optimized GradientBoosting model by default instead of xgboost_v1 Added conditional logic to route to predictor_optimized when model is "optimized", "gradientboosting", or "best" Maintains fallback to legacy XGBoost predictor for backward compatibility Improved documentation with model name options +18/-4
Configuration changes	1 files config.py ATR-Based TP/SL, Adaptive Sizing, and ML Auto-Calibration System config.py Migrated TP/SL system from FIXE mode to ATR-based HYBRID INTELLIGENT mode with dynamic volatility adaptation Added stagnation exit (time decay) feature to exit trades after 2 minutes of no movement Introduced anti-whipsaw filter, retest confirmation, cooldown post-trade, and momentum continuity filters Added adaptive sizing system that adjusts position size based on real-time win rate per pair/session Implemented HistGradientBoosting ML model with auto-calibration system for dynamic confidence adjustment Added BYPASS mode configuration with browser token support and live entry synchronization parameters Expanded scalability scan parameters with configurable spread, volume, funding rate, and ADX thresholds Added ML auto-calibration system that recalibrates confidence based on live trading results +160/-23
Miscellaneous	1 files check_all_configs.py Database Configuration Analysis Utility Script                      scripts/utilities/check_all_configs.py New utility script to analyze all configuration columns stored in the trades database table Displays unique values and counts for each config_* column to understand configuration usage patterns Shows top 15 unique combinations of key config parameters (score, SNR, volume multiplier, confluence) Helps identify which configurations are actually being used in live trading +87/-0
Tools	1 files diagnose_ml_pipeline.py ML Pipeline Diagnostic Tool for Troubleshooting                    scripts/verification/diagnose_ml_pipeline.py New comprehensive diagnostic script for ML pipeline troubleshooting Analyzes data quality, target distribution, feature-target correlation, temporal patterns, and class separability Implements test suite with simple rules baseline, ensemble approach, and feature engineering improvements Generates detailed reports with identified problems and actionable solutions +563/-0
Additional files	101 files test.yml +1/-1      FONCTIONNEMENT_LIVE_TRADING.md +370/-0  MAINTAINABILITY_ANALYSIS.md +1394/-0 PHASE4_ML_SPLIT_PLAN.md +126/-0  PHASE4_SUMMARY.md +207/-0  analyze_trades.py +129/-0  live_trading_endpoints.py +359/-3  price_provider.py +178/-11 __init__.py +4/-0      config.py +123/-0  ml_calibration.py +227/-0  ml_common.py +137/-0  ml_dashboard.py +393/-0  ml_legacy.py +4801/-0 ml_models.py +496/-0  ml_predictions.py +308/-0  ml_tasks.py +129/-0  audit_gradientboosting_results.json +106/-0  auto_optimize_ml.py +350/-0  balance_all.py +219/-0  config_overrides.json +95/-37  analyzer.py +165/-187 __init__.py +22/-1    advanced_filters.py +535/-0  position_check_loop.py +77/-6    scalability_refresh.py +114/-11 scanner_loop.py +344/-18 config_manager.py +232/-3  adaptive_sizing.py +357/-0  early_invalidation.py +126/-32 position_manager.py +1109/-102 postgresql_datalogger.py +658/-479 scanner.py +425/-47 contract_specs_cache.json +195/-0  optuna_gb_results.json +93/-0    optuna_last_runs.json +46/-15  optuna_loop_results_f1_score.json +109/-0  create_ml_view.sql +14/-0    migration_add_config_columns.sql +172/-2  add_ml_calibration_table.sql +95/-0    add_ml_confidence_threshold.sql +31/-0    add_orderflow_columns.sql +58/-0    BRAINSTORM_ML_ARCHITECTURE.md +898/-0  BYPASS_IMPLEMENTATION_REVIEW.md +223/-0  MEXC_BYPASS_MODE.md +149/-0  ML_MODELS_GUIDE.md +324/-0  ML_PERFORMANCE_ANALYSIS.md +124/-0  RECAP_ML_TRAINING_29NOV2025.md +216/-0  UNIFIED_ML_FILTERING_SUMMARY.md +88/-0    export_datalogger_to_excel.py +3/-1      README.md +94/-0    background.js +109/-0  content.js +63/-0    manifest.json +40/-0    popup.css +233/-0  popup.html +50/-0    popup.js +261/-0  final_push.py +323/-0  LiveTradingPanel.svelte +208/-4  NotificationSettings.svelte +246/-18 PositionCard.svelte +165/-7  TradeHistory.svelte +124/-53 VariablesPanel.svelte +1319/-22 MLCONTENT_GB_Variables.svelte +3517/-0 position.js +13/-1    format.js +16/-3    +page.svelte +2/-1      gb_optimization_report.json +34/-0    hyperparams_comparison_results.json +119/-0  calibration.py +626/-0  hyperparameter_tuning.py +6/-3      ml_diagnostic_report.json +29/-0    ml_negative_filter.py +291/-0  ml_validation_report.json +68/-0    ml_verification_report.json +34/-0    telegram_notifier.py +157/-2  feature_engineering.py +50/-0    feature_loader.py +197/-50 xgboost_trainer_v2.py +271/-6  multi_config_backtest.py +214/-0  optuna_gb_tuner.py +423/-0  optuna_gradientboosting.py +416/-0  optuna_v2_tuner.py +140/-70 per_symbol_models.py +596/-0  predictor.py +37/-3    predictor_negative.py +314/-0  predictor_optimized.py +311/-0  predictor_v2.py +22/-2    best_classifier_metadata.json +85/-0    ensemble_best_metadata.json +25/-0    gb_optuna_metadata.json +66/-0    gb_optuna_results.json +13/-0    gradient_boosting_anti_overfit_metadata.json +68/-0    gradient_boosting_best_metadata.json +25/-0    gradient_boosting_optimized_metadata.json +91/-0    high_precision_best_metadata.json +25/-0    optimization_report.txt +53/-0    optimized_classifier_metadata.json +115/-0  validation_test_metadata.json +176/-0  xgboost_best_metadata.json +25/-0    Additional files not shown

---

[qodo-code-review]

PR Compliance Guide 🔍

Below is a summary of compliance checks for this PR:

Security Compliance
⚪	Race condition Description: Unsynchronized background thread started with shared state access in _schedule_position_sync (using threading and time.sleep without locks) can introduce race conditions on position fields (e.g., TP/SL, size) leading to inconsistent state and potentially unsafe order decisions. position_manager.py [401-406] Referred Code thread = threading.Thread(target=_worker, name=f"position_sync_{symbol}", daemon=True) try: thread.start() except RuntimeError as e: logger.error(f"❌ Impossible de démarrer le thread de resynchronisation pour {symbol}: {e}")
	Blocking delay risk Description: Blocking sleep before closing positions (enforcing MIN_LIVE_TRADE_DURATION_SEC) delays order submission and can increase market risk or violate risk controls by intentionally waiting before exit. position_manager.py [2109-2117] Referred Code wait_time = MIN_LIVE_TRADE_DURATION_SEC - duration if wait_time > 0: logger.info( f"⏳ Durée position {duration}s < {MIN_LIVE_TRADE_DURATION_SEC}s (raison={reason}). " f"Attente {wait_time:.1f}s avant fermeture." ) time.sleep(wait_time) duration = int(time.time() - self.active_position.start_time)
	Notification reliability Description: Asynchronous notifications are launched from synchronous code using asyncio.get_event_loop with create_task/asyncio.run; improper loop handling and lack of error propagation may drop critical alerts (e.g., risk/circuit-breaker notifications), reducing operational visibility. position_manager.py [1219-1231] Referred Code try: loop = asyncio.get_event_loop() if loop.is_running(): loop.create_task( self.notification_manager.notify('position_opened', position_data, priority='info') ) else: asyncio.run(self.notification_manager.notify('position_opened', position_data, priority='info')) except RuntimeError: # Pas de loop, ignorer notification pass except Exception as e: logger.debug(f"Erreur envoi notification position_opened: {e}")
	Untrusted config use Description: Direct import and global use of TRADING_CONFIG without validation allows untrusted or dynamic config values to influence trading logic (thresholds, timeouts) at runtime; if config source is not integrity-protected this could be abused to bypass safeguards. advanced_filters.py [11-15] Referred Code from typing import Dict, Optional, List, Any from dataclasses import dataclass, field from config import TRADING_CONFIG logger = logging.getLogger(__name__)
Ticket Compliance
⚪	🎫 No ticket provided Create ticket/issue
Codebase Duplication Compliance
⚪	Codebase context is not defined Follow the guide to enable codebase context checks.
Custom Compliance
⚪	Generic: Comprehensive Audit Trails Objective: To create a detailed and reliable record of critical system actions for security analysis and compliance. Status: Missing audit context: New critical actions (live order placement/closure, TP/SL triggers, calibration updates) are logged but lack a consistent structured audit trail with user/entity identifiers and outcomes suitable for forensic reconstruction. Referred Code self.active_position.tp_escalier_levels = levels_config # 🔥 LIVE TRADING: Passer ordre réel si LiveOrderManager actif executed_size_usdt = size if self.live_order_manager: try: # Calculer la taille en tokens (amount) depuis la taille en USDT size_amount = size / entry # 🔥 FIX: Récupérer le levier depuis TRADING_CONFIG (pas celui de l'init) configured_leverage = TRADING_CONFIG.get('default_leverage', 10) # 🔍 VÉRIFICATION LEVIER: Logger pour debug logger.info( f"🔍 LEVIER CHECK: config={configured_leverage}x | " f"live_manager_default={self.live_order_manager.default_leverage}x | " f"Utilisation: {configured_leverage}x" ) order_result = self.live_order_manager.open_position( ... (clipped 181 lines) Learn more about managing compliance generic rules or creating your own custom rules
	Generic: Meaningful Naming and Self-Documenting Code Objective: Ensure all identifiers clearly express their purpose and intent, making code self-documenting Status: Mixed language names: Several new identifiers and comments mix French and English and include emojis (e.g., force_full_tp_for_partial OK but comments like "FIX CRITIQUE") which may hurt long-term readability and consistency across the codebase. Referred Code # 🔥 ML & Sizing Adaptatif (pour affichage frontend) ml_confidence: Optional[float] = None # Confiance ML au moment de l'ouverture (%) ml_calibrated_winrate: Optional[float] = None # 🔥 WR Réel calibré (si disponible) adaptive_sizing_multiplier: Optional[float] = None # Multiplicateur sizing adaptatif (0.5-1.5) # 🔥 FIX: Min contract amount pour validation TP partiel min_contract_amount: Optional[float] = None # Minimum du contrat en tokens force_full_tp_for_partial: bool = False # Si True, le TP partiel fermera 100% car qty < min time_to_fill_entry_ms: Optional[float] = None time_to_fill_exit_ms: Optional[float] = None price_at_signal: Optional[float] = None price_at_order_sent: Optional[float] = None signal_to_fill_slippage_pct: Optional[float] = None api_errors: Optional[Any] = None retry_count: int = 0 exchange_latency_ms: Optional[float] = None ws_latency_ms: Optional[float] = None def to_dict(self) -> Dict[str, Any]: ... (clipped 74 lines) Learn more about managing compliance generic rules or creating your own custom rules
	Generic: Robust Error Handling and Edge Case Management Objective: Ensure comprehensive error handling that provides meaningful context and graceful degradation Status: Async callback risks: The real-time SL check schedules asyncio tasks in a WS callback without guarding for backpressure or callback reentrancy, which may lead to missed errors or task buildup under load. Referred Code # Cela garantit une détection immédiate du SL, pas toutes les 2 secondes if self._sl_check_callback and self._sl_check_params: params = self._sl_check_params if params.get('symbol') == ccxt_symbol: try: loop = asyncio.get_running_loop() # Fire-and-forget: vérifier SL immédiatement asyncio.create_task( self._check_sl_realtime(last_price, params) ) except RuntimeError: # Pas de boucle, ignorer (ne devrait pas arriver) pass Learn more about managing compliance generic rules or creating your own custom rules
	Generic: Secure Error Handling Objective: To prevent the leakage of sensitive system information through error messages while providing sufficient detail for internal debugging. Status: Trace log exposure: Logging of exceptions and full tracebacks in real-time SL callback and emit paths may expose internal details if logs are user-accessible; verify logs are internal-only and redacted. Referred Code await callback(current_price, reason) except Exception as e: logger.error(f"❌ Erreur callback SL temps réel: {e}") import traceback logger.debug(traceback.format_exc()) Learn more about managing compliance generic rules or creating your own custom rules
	Generic: Secure Logging Practices Objective: To ensure logs are useful for debugging and auditing without exposing sensitive information like PII, PHI, or cardholder data. Status: Sensitive data in logs: New logs may include raw API responses, leverage, sizes, and funding rates; ensure secrets/tokens and any user-identifying info are not logged and outputs are structured if used for auditing. Referred Code 'funding_rate_at_entry': getattr(self.active_position, 'funding_rate_at_entry', None), 'funding_rate_at_exit': getattr(self.active_position, 'funding_rate_at_exit', None), 'entry_api_response': getattr(self.active_position, 'entry_api_response', None), 'exit_api_response': getattr(self.active_position, 'exit_api_response', None), # 🔥 FIX: Ajouter ml_confidence au trade (même valeur que dans scan_logs) 'ml_confidence': getattr(self.active_position, 'ml_confidence', None) } Learn more about managing compliance generic rules or creating your own custom rules
	Generic: Security-First Input Validation and Data Handling Objective: Ensure all data inputs are validated, sanitized, and handled securely to prevent vulnerabilities Status: External data trust: Live sync and contract size retrieval trust external API fields (e.g., tokens, contract_size) without explicit validation or bounds checks, which may propagate bad data to sizing/PNL calculations. Referred Code # prefer_ccxt=True pour utiliser CCXT en priorité (économise bypass) live_position = self.live_order_manager.get_position(symbol, prefer_ccxt=True) if live_position: live_entry_price = float(live_position.get('entry_price') or 0) # 🔥 FIX: Utiliser 'tokens' directement (déjà calculé = contracts × contract_size) real_tokens = float(live_position.get('tokens') or 0) live_contracts = float(live_position.get('contracts') or 0) logger.info( f"🔁 [LIVE] get_position: tokens={real_tokens:.6f}, contracts={live_contracts}, " f"contract_size={live_position.get('contract_size')}, entry={live_entry_price}" ) if live_entry_price > 0: previous_entry = self.active_position.entry if abs(live_entry_price - previous_entry) > 1e-8: price_diff = live_entry_price - previous_entry if direction == 'LONG': self.active_position.tp += price_diff self.active_position.sl += price_diff else: ... (clipped 26 lines) Learn more about managing compliance generic rules or creating your own custom rules

Compliance status legend

🟢 - Fully Compliant
🟡 - Partial Compliant
🔴 - Not Compliant
⚪ - Requires Further Human Verification
🏷️ - Compliance label

[qodo-code-review]

PR Code Suggestions ✨

Explore these optional code suggestions:

Category	Suggestion	Impact
Possible issue	Prevent closing wrong position on SL In the on_sl_triggered callback, add a check to verify that the active position's symbol matches the symbol that triggered the stop-loss before closing the position. main.py [816-867] async def on_sl_triggered(exit_price: float, reason: str): """Callback appelé immédiatement quand SL est touché via WebSocket""" logger.info(f"⚡ SL temps réel déclenché: {symbol} @ {exit_price:.8f} | Raison: {reason}") # Acquérir le lock pour éviter les conditions de course async with position_lock: # Vérifier que la position est toujours active if not position_manager or not position_manager.active_position: logger.debug("Position déjà fermée, callback SL ignoré") return + # Vérifier que le symbole de la position active correspond au trigger + if position_manager.active_position.symbol != symbol: + logger.warning(f"Callback SL pour {symbol} ignoré, position active est pour {position_manager.active_position.symbol}") + return + # Fermer la position try: result = position_manager.close_position(exit_price=exit_price, reason=reason) # Mettre à jour l'état app_state['active_position'] = None # Archiver dans l'historique if result: result['timestamp'] = datetime.now().isoformat() if 'trade_history' not in app_state: app_state['trade_history'] = [] app_state['trade_history'].append(result) # Limiter l'historique if len(app_state['trade_history']) > 1000: app_state['trade_history'] = app_state['trade_history'][-1000:] # Désactiver le callback SL (déjà fait dans price_provider) if price_provider: price_provider.set_sl_check_callback(None) # 🔥 FIX SL MISMATCH V2: Annuler tâche SL en attente cancel_pending_sl_task(symbol) # Émettre événement de fermeture if ws_manager: await ws_manager.emit('position_closed', result) # Stats update await ws_manager.emit('stats_update', app_state.get('stats', {})) logger.info( f"✅ Position fermée via SL temps réel: {symbol} | " f"PnL: {result.get('pnl_percent', 0):+.2f}% | " f"Raison: {reason}" ) except Exception as e: logger.error(f"❌ Erreur fermeture position SL temps réel: {e}") import traceback logger.debug(traceback.format_exc()) Apply / Chat Suggestion importance[1-10]: 10 __ Why: The suggestion identifies a critical race condition in the on_sl_triggered callback where a stale trigger could close the wrong active position, and the proposed symbol check is the correct fix.	High
	Fix race condition in position check Wrap the logic in position_check_loop_callback with async with position_lock to prevent race conditions when accessing the active position. main.py [2341-2618] async def position_check_loop_callback() -> None: """ Callback appelé périodiquement pour surveiller et gérer la position active. ... """ init_instances() # Vérifier si on a une position active if not position_manager or not position_manager.active_position: return - position = position_manager.active_position - # 🔥 FIX: Verrouiller pour éviter race condition if position_lock.locked(): return - try: - # 🔥 FIX: Import TRADING_CONFIG pour position_update - from config import TRADING_CONFIG - from datetime import datetime # 🔥 FIX: Import au début du try pour éviter UnboundLocalError - - # Récupérer prix actuel - current_price_data = await price_provider.get_price(position_manager.active_position.symbol) - if not current_price_data: + async with position_lock: + # Re-vérifier la position après avoir acquis le lock + if not position_manager or not position_manager.active_position: return - current_price = get_preferred_price(current_price_data) + position = position_manager.active_position - # Check position (renvoie None ou raison de fermeture) - close_reason = await position_manager.check_position(current_price) - - # Si pas de raison de fermer, mettre à jour PnL et sortir - if not close_reason: - # Calculer PnL - pnl, pnl_usdt = position_manager.pnl_calculator.calculate_pnl( - entry=position.entry, - exit_price=current_price, - direction=position.direction, - size=position.size - ) - - # 🔥 FIX: Log pour debug - logger.debug( - f"Position check: {position.symbol} | PnL: {pnl:.2f}% | " - f"Prix: {current_price:.6f} | " - f"SL={position.sl:.6f} | TP={position.tp:.6f}" - ) - - # 🔥 FIX: Récupérer ml_confidence depuis PostgreSQL si null sur la position - ml_conf = getattr(position, 'ml_confidence', None) - if ml_conf is None: - try: - from core.callbacks.scanner_loop import get_pg_datalogger - pg_logger = get_pg_datalogger() - if pg_logger and pg_logger.enabled: - ml_conf = pg_logger.get_ml_confidence_for_symbol(position.symbol) - if ml_conf is not None: - position.ml_confidence = round(ml_conf, 1) # Arrondir et stocker - ml_conf = position.ml_confidence - except Exception as e: - logger.debug(f"⚠️ Impossible de charger ml_confidence depuis PostgreSQL: {e}") - - # 🔥 FIX: Récupérer adaptive_sizing_multiplier depuis PostgreSQL si null sur la position - sizing_mult = getattr(position, 'adaptive_sizing_multiplier', None) - if sizing_mult is None: - try: - from core.callbacks.scanner_loop import get_pg_datalogger - pg_logger = get_pg_datalogger() - if pg_logger and pg_logger.enabled: - sizing_mult = pg_logger.get_adaptive_sizing_for_symbol(position.symbol) - if sizing_mult is not None: - position.adaptive_sizing_multiplier = sizing_mult - except Exception as e: - logger.debug(f"⚠️ Impossible de charger sizing_multiplier depuis PostgreSQL: {e}") + try: + # 🔥 FIX: Import TRADING_CONFIG pour position_update + from config import TRADING_CONFIG + from datetime import datetime # 🔥 FIX: Import au début du try pour éviter UnboundLocalError + + # Récupérer prix actuel + current_price_data = await price_provider.get_price(position_manager.active_position.symbol) + if not current_price_data: + return + + current_price = get_preferred_price(current_price_data) + + # Check position (renvoie None ou raison de fermeture) + close_reason = await position_manager.check_position(current_price) + + # Si pas de raison de fermer, mettre à jour PnL et sortir + if not close_reason: + # Calculer PnL + pnl, pnl_usdt = position_manager.pnl_calculator.calculate_pnl( + entry=position.entry, + exit_price=current_price, + direction=position.direction, + size=position.size + ) + + # 🔥 FIX: Log pour debug + logger.debug( + f"Position check: {position.symbol} | PnL: {pnl:.2f}% | " + f"Prix: {current_price:.6f} | " + f"SL={position.sl:.6f} | TP={position.tp:.6f}" + ) + + # 🔥 FIX: Récupérer ml_confidence depuis PostgreSQL si null sur la position + ml_conf = getattr(position, 'ml_confidence', None) + if ml_conf is None: + try: + from core.callbacks.scanner_loop import get_pg_datalogger + pg_logger = get_pg_datalogger() + if pg_logger and pg_logger.enabled: + ml_conf = pg_logger.get_ml_confidence_for_symbol(position.symbol) + if ml_conf is not None: + position.ml_confidence = round(ml_conf, 1) # Arrondir et stocker + ml_conf = position.ml_confidence + except Exception as e: + logger.debug(f"⚠️ Impossible de charger ml_confidence depuis PostgreSQL: {e}") + + # 🔥 FIX: Récupérer adaptive_sizing_multiplier depuis PostgreSQL si null sur la position + sizing_mult = getattr(position, 'adaptive_sizing_multiplier', None) + if sizing_mult is None: + try: + from core.callbacks.scanner_loop import get_pg_datalogger + pg_logger = get_pg_datalogger() + if pg_logger and pg_logger.enabled: + sizing_mult = pg_logger.get_adaptive_sizing_for_symbol(position.symbol) + if sizing_mult is not None: + position.adaptive_sizing_multiplier = sizing_mult + except Exception as e: + logger.debug(f"⚠️ Impossible de charger sizing_multiplier depuis PostgreSQL: {e}") - # 🔥 FIX: Calculer opened_at depuis start_time (opened_at n'est pas un attribut direct) - opened_at_iso = None - if position.start_time: - opened_at_iso = datetime.fromtimestamp(position.start_time).isoformat() - - # Émettre update pour le frontend (inclut aussi les tailles en contrats) - update_data = { - 'symbol': position.symbol, - 'direction': position.direction, - 'entry': position.entry, - 'current_price': current_price, - 'tp': position.tp, - 'sl': position.sl, - 'pnl': pnl, - 'pnl_usdt': pnl_usdt, - 'size': position.size, - 'break_even_set': position.break_even_set, - 'partial_tp_sold': position.partial_tp_sold, - 'position_size_contracts': getattr(position, 'position_size_contracts', None), - 'size_initial_contracts': getattr(position, 'size_initial_contracts', None), - 'size_remaining_contracts': getattr(position, 'size_remaining_contracts', None), - # 🔥 FIX: Ajouter ml_confidence et adaptive_sizing_multiplier - 'ml_confidence': ml_conf, - 'adaptive_sizing_multiplier': sizing_mult, - # 🔥 FIX: Ajouter tp_sl_mode, opened_at et force_full_tp pour affichage ATR - 'tp_sl_mode': TRADING_CONFIG.get('tp_sl_mode', 'FIXE'), - 'opened_at': opened_at_iso, # 🔥 FIX: Calculé depuis start_time - 'force_full_tp_for_partial': getattr(position, 'force_full_tp_for_partial', False), - 'leverage_used': getattr(position, 'leverage_used', None), - } - await ws_manager.emit('position_update', update_data) - - # 🔥 PHASE 8: Mettre à jour les métriques de la position - if metrics_collector: - metrics_collector.update_position_metrics(pnl, pnl_usdt) - - return - - # Si on arrive ici, c'est qu'il faut fermer la position - logger.info(f"Fermeture position: {position.symbol} | Raison: {close_reason}") - - async with position_lock: + # 🔥 FIX: Calculer opened_at depuis start_time (opened_at n'est pas un attribut direct) + opened_at_iso = None + if position.start_time: + opened_at_iso = datetime.fromtimestamp(position.start_time).isoformat() + + # Émettre update pour le frontend (inclut aussi les tailles en contrats) + update_data = { + 'symbol': position.symbol, + 'direction': position.direction, + 'entry': position.entry, + 'current_price': current_price, + 'tp': position.tp, + 'sl': position.sl, + 'pnl': pnl, + 'pnl_usdt': pnl_usdt, + 'size': position.size, + 'break_even_set': position.break_even_set, + 'partial_tp_sold': position.partial_tp_sold, + 'position_size_contracts': getattr(position, 'position_size_contracts', None), + 'size_initial_contracts': getattr(position, 'size_initial_contracts', None), + 'size_remaining_contracts': getattr(position, 'size_remaining_contracts', None), + # 🔥 FIX: Ajouter ml_confidence et adaptive_sizing_multiplier + 'ml_confidence': ml_conf, + 'adaptive_sizing_multiplier': sizing_mult, + # 🔥 FIX: Ajouter tp_sl_mode, opened_at et force_full_tp pour affichage ATR + 'tp_sl_mode': TRADING_CONFIG.get('tp_sl_mode', 'FIXE'), + 'opened_at': opened_at_iso, # 🔥 FIX: Calculé depuis start_time + 'force_full_tp_for_partial': getattr(position, 'force_full_tp_for_partial', False), + 'leverage_used': getattr(position, 'leverage_used', None), + } + await ws_manager.emit('position_update', update_data) + + # 🔥 PHASE 8: Mettre à jour les métriques de la position + if metrics_collector: + metrics_collector.update_position_metrics(pnl, pnl_usdt) + + return + + # Si on arrive ici, c'est qu'il faut fermer la position + logger.info(f"Fermeture position: {position.symbol} | Raison: {close_reason}") + result = position_manager.close_position(exit_price=current_price, reason=close_reason) app_state['active_position'] = None # 🔥 FIX: Reset compteur d'échecs après fermeture réussie app_state['close_failure_count'] = 0 app_state['close_failure_symbol'] = None # 🔥 PHASE 4: Ajouter à l'historique et sauvegarder if result: result['timestamp'] = datetime.now().isoformat() app_state['trade_history'].append(result) save_trade_history() # 🔥 FIX: Désactiver callback WebSocket si position fermée if price_provider: price_provider.set_socketio_callback(None, None) # 🔥 FIX SL MISMATCH: Désactiver callback SL temps réel price_provider.set_sl_check_callback(None) # 🔥 FIX SL MISMATCH V2: Annuler tâche SL en attente closed_symbol = result.get('symbol') if result else None if closed_symbol: cancel_pending_sl_task(closed_symbol) # 🔥 FIX: Log pour debug logger.info( f"✅ Position fermée avec lock: {position.symbol} | " f"PnL: {result.get('pnl_percent', 0):.2f}% | " f"Raison: {close_reason}" ) # Émettre événement de fermeture await ws_manager.emit('position_closed', result) # Mettre à jour stats await ws_manager.emit('stats_update', app_state.get('stats', {})) # 🔥 PHASE 8: Mettre à jour les métriques de la position if metrics_collector: metrics_collector.reset_position_metrics() - - except Exception as e: - logger.error(f"Erreur dans position check loop: {e}") - await add_log('ERROR', 'Erreur position check', str(e)) - # 🔥 FIX: Compteur d'échecs pour éviter boucle infinie - # Si même position échoue 5+ fois, forcer fermeture locale - if position_manager and position_manager.active_position: - current_symbol = position_manager.active_position.symbol - if app_state['close_failure_symbol'] == current_symbol: - app_state['close_failure_count'] += 1 - else: - app_state['close_failure_symbol'] = current_symbol - app_state['close_failure_count'] = 1 - - # Après 5 échecs consécutifs, forcer fermeture locale (paper close) - if app_state['close_failure_count'] >= 5: - logger.warning( - f"⚠️ FORCE CLOSE: {current_symbol} - {app_state['close_failure_count']} échecs consécutifs | " - f"Fermeture locale forcée pour éviter boucle infinie" - ) - try: - async with position_lock: + except Exception as e: + logger.error(f"Erreur dans position check loop: {e}") + await add_log('ERROR', 'Erreur position check', str(e)) + + # 🔥 FIX: Compteur d'échecs pour éviter boucle infinie + # Si même position échoue 5+ fois, forcer fermeture locale + if position_manager and position_manager.active_position: + current_symbol = position_manager.active_position.symbol + if app_state['close_failure_symbol'] == current_symbol: + app_state['close_failure_count'] += 1 + else: + app_state['close_failure_symbol'] = current_symbol + app_state['close_failure_count'] = 1 + + # Après 5 échecs consécutifs, forcer fermeture locale (paper close) + if app_state['close_failure_count'] >= 5: + logger.warning( + f"⚠️ FORCE CLOSE: {current_symbol} - {app_state['close_failure_count']} échecs consécutifs | " + f"Fermeture locale forcée pour éviter boucle infinie" + ) + try: # Forcer fermeture sans ordre (skip_order=True) result = position_manager.close_position( exit_price=position_manager.active_position.entry, # Utiliser prix d'entrée comme fallback reason='FORCE_CLOSE', skip_order=True # Ne pas envoyer d'ordre à MEXC ) app_state['active_position'] = None app_state['close_failure_count'] = 0 app_state['close_failure_symbol'] = None if result: result['timestamp'] = datetime.now().isoformat() app_state['trade_history'].append(result) save_trade_history() logger.info(f"✅ FORCE CLOSE réussi: {current_symbol}") await ws_manager.emit('position_closed', result) - except Exception as force_e: - logger.error(f"❌ FORCE CLOSE échoué: {force_e} - Réinitialisation position") - position_manager.active_position = None - app_state['active_position'] = None - app_state['close_failure_count'] = 0 - app_state['close_failure_symbol'] = None + except Exception as force_e: + logger.error(f"❌ FORCE CLOSE échoué: {force_e} - Réinitialisation position") + position_manager.active_position = None + app_state['active_position'] = None + app_state['close_failure_count'] = 0 + app_state['close_failure_symbol'] = None [To ensure code accuracy, apply this suggestion manually] Suggestion importance[1-10]: 9 __ Why: The suggestion correctly identifies a critical race condition in position_check_loop_callback where the shared position state is accessed without a lock, and proposes a correct fix using async with position_lock.	High
	Fix race condition in SL placement In _delayed_sl_placement, wrap the logic that accesses and modifies the active position within an async with position_lock block to prevent race conditions. main.py [915-982] async def _delayed_sl_placement(): """Tâche interne qui attend puis place l'ordre SL""" try: logger.info(f"⏳ Attente {delay_seconds}s avant placement ordre SL sur exchange pour {symbol}...") await asyncio.sleep(delay_seconds) - # Vérifier si la position est toujours active - if not position_manager or not position_manager.active_position: - logger.info(f"ℹ️ Position {symbol} déjà fermée, annulation placement SL exchange") - return - - active_pos = position_manager.active_position - if active_pos.symbol != symbol: - logger.info(f"ℹ️ Symbole actif différent ({active_pos.symbol} vs {symbol}), annulation") - return - - # Récupérer les paramètres actuels de la position - entry_price = active_pos.entry_fill_price or active_pos.entry - sl_level = active_pos.sl - direction = active_pos.direction - - if not all([entry_price, sl_level, direction]): - logger.warning(f"⚠️ Paramètres manquants pour SL exchange: entry={entry_price}, sl={sl_level}, dir={direction}") - return - - # Vérifier si le live_order_manager est disponible et pas en dry-run - if not live_order_manager: - logger.debug(f"ℹ️ Pas de live_order_manager, SL exchange non placé") - return - - if live_order_manager.dry_run: - logger.info( - f"🛡️ [DRY_RUN] Ordre SL exchange simulé: {symbol} {direction} | " - f"Entry={entry_price:.8f} | SL={sl_level:.8f}" - ) - return - - # 🔥 Placer l'ordre SL via bypass - if hasattr(live_order_manager, 'place_stop_loss_order'): - result = await live_order_manager.place_stop_loss_order( - symbol=symbol, - direction=direction, - sl_price=sl_level, - entry_price=entry_price - ) - if result and result.success: + async with position_lock: + # Vérifier si la position est toujours active + if not position_manager or not position_manager.active_position: + logger.info(f"ℹ️ Position {symbol} déjà fermée, annulation placement SL exchange") + return + + active_pos = position_manager.active_position + if active_pos.symbol != symbol: + logger.info(f"ℹ️ Symbole actif différent ({active_pos.symbol} vs {symbol}), annulation") + return + + # Récupérer les paramètres actuels de la position + entry_price = active_pos.entry_fill_price or active_pos.entry + sl_level = active_pos.sl + direction = active_pos.direction + + if not all([entry_price, sl_level, direction]): + logger.warning(f"⚠️ Paramètres manquants pour SL exchange: entry={entry_price}, sl={sl_level}, dir={direction}") + return + + # Vérifier si le live_order_manager est disponible et pas en dry-run + if not live_order_manager: + logger.debug(f"ℹ️ Pas de live_order_manager, SL exchange non placé") + return + + if live_order_manager.dry_run: logger.info( - f"✅ Ordre SL placé sur exchange: {symbol} | " - f"SL={sl_level:.8f} | Order ID={result.order_id}" + f"🛡️ [DRY_RUN] Ordre SL exchange simulé: {symbol} {direction} | " + f"Entry={entry_price:.8f} | SL={sl_level:.8f}" ) - # Stocker l'ID de l'ordre SL dans la position - active_pos.sl_order_id = result.order_id + return + + # 🔥 Placer l'ordre SL via bypass + if hasattr(live_order_manager, 'place_stop_loss_order'): + result = await live_order_manager.place_stop_loss_order( + symbol=symbol, + direction=direction, + sl_price=sl_level, + entry_price=entry_price + ) + if result and result.success: + logger.info( + f"✅ Ordre SL placé sur exchange: {symbol} | " + f"SL={sl_level:.8f} | Order ID={result.order_id}" + ) + # Stocker l'ID de l'ordre SL dans la position + active_pos.sl_order_id = result.order_id + else: + error_msg = result.error_message if result else "Méthode indisponible" + logger.warning(f"⚠️ Échec placement SL exchange: {error_msg}") else: - error_msg = result.error_message if result else "Méthode indisponible" - logger.warning(f"⚠️ Échec placement SL exchange: {error_msg}") - else: - logger.debug(f"ℹ️ Méthode place_stop_loss_order non disponible") + logger.debug(f"ℹ️ Méthode place_stop_loss_order non disponible") except asyncio.CancelledError: logger.info(f"🛑 Tâche SL annulée pour {symbol}") except Exception as e: logger.error(f"❌ Erreur placement SL exchange: {e}") import traceback logger.debug(traceback.format_exc()) finally: # Nettoyer la tâche if symbol in _pending_sl_tasks: del _pending_sl_tasks[symbol] Apply / Chat Suggestion importance[1-10]: 9 __ Why: The suggestion correctly identifies a race condition in _delayed_sl_placement where the active position is accessed and modified without a lock, and proposes the correct fix using async with position_lock.	High
	Fix incorrect serialization of lists Improve the list cleaning logic to correctly handle nested lists and dictionaries, preventing them from being converted to strings during serialization. api/routes/ml_legacy.py [1557-1575] # 🔥 FIX: Nettoyer les données non-sérialisables (coroutines, objets, etc.) clean_data = {} for key, value in task_data.items(): if value is None: clean_data[key] = None elif isinstance(value, (str, int, float, bool)): clean_data[key] = value elif isinstance(value, dict): clean_data[key] = { k: str(v) if not isinstance(v, (str, int, float, bool, type(None), list, dict)) else v for k, v in value.items() } elif isinstance(value, list): clean_data[key] = [ - str(v) if not isinstance(v, (str, int, float, bool, type(None))) else v + str(v) if not isinstance(v, (str, int, float, bool, type(None), list, dict)) else v for v in value ] else: clean_data[key] = str(value) Apply / Chat Suggestion importance[1-10]: 7 __ Why: The suggestion correctly identifies a bug where nested lists or dictionaries within a list are improperly serialized to strings, and the proposed fix correctly resolves this issue.	Medium
More