# source: https://raw.githubusercontent.com/vigoferrel/qbtc-unified/ef7ffc8f45cc7ab041884cd0c08a2043acc1f0cb/freqtrade_qbtc/strategies/QBTCQuantumAngularElite.py # pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement """ 🌌 QBTC QUANTUM ANGULAR ELITE STRATEGY 🌌 Estrategia cuántica angular integrada con todo el stack QBTC-UNIFIED INTEGRACIÓN COMPLETA: ✅ MetaConsciencia (14020) - Decisiones inteligentes IA ✅ QBTC Kernel (14050) - Estado cuántico del sistema ✅ Strategic Brain (14030) - Estrategias avanzadas ✅ Risk Brain (14031) - Gestión de riesgo inteligente ✅ Operational Brain (14032) - Optimización operativa ✅ Evolution Brain (14033) - Aprendizaje evolutivo ✅ Inter-Brain Communication (14034) - Comunicación cerebral ✅ Collaborative Engine (14035) - Motor de decisiones colaborativas ✅ Guardian System - Protección y safety-kill ✅ Portfolio Manager - Gestión de cartera avanzada ✅ Leonardo Master Control (14001) - Orquestación maestra """ import numpy as np import pandas as pd from pandas import DataFrame from typing import Optional, Union, Dict, List, Tuple, Any import math import logging import requests import json from datetime import datetime, timezone from freqtrade.strategy import ( IStrategy, IntParameter, DecimalParameter, BooleanParameter, ) import talib.abstract as ta class Github_vigoferrel_qbtc_unified__QBTCQuantumAngularElite__20251009_202533(IStrategy): """ 🌊 QBTC Quantum Angular Elite Strategy - REVOLUCIÓN ANTI-TRADING NUEVA FILOSOFÍA RADICAL: - ANTI-TRADING: Solo operar cuando NO queremos operar - PARADOJA CUÁNTICA: Las mejores oportunidades aparecen cuando las rechazamos - INVERSIÓN DE LÓGICA: Si todos los indicadores dicen BUY, vendemos - CONSCIENCIA INVERSA: Máxima ganancia en mínima actividad - ZEN TRADING: El mejor trade es el que NO hacemos PRINCIPIO FUNDAMENTAL: 'MENOS ES EXPONENCIALMENTE MÁS' """ INTERFACE_VERSION = 3 can_short: bool = False timeframe = '15m' startup_candle_count: int = 144 # Fibonacci sequence # ==================== GEOMETRÍA SAGRADA AVANZADA ==================== PHI = 1.618033988749 # Golden Ratio PHI_SQUARED = PHI ** 2 # φ² = 2.618 PHI_CUBED = PHI ** 3 # φ³ = 4.236 PHI_ANGLE = 137.5077641 # Precise Golden Angle FIBONACCI_ANGLES = [23.6, 38.2, 50.0, 61.8, 78.6, 127.2, 161.8] SACRED_ANGLES = [30, 45, 60, 72, 90, 108, 120, 144, 180, 216, 270, 288] PRIME_ANGLES = [7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47] # ==================== ROI CUÁNTICO DIMENSIONAL ==================== # ANTI-TRADING ROI: Solo movimientos MASIVOS merecen nuestra atención minimal_roi = { "0": 0.50, # 50% ganancia mínima - Si no es MASIVO, no vale la pena "21": 0.30, # 30% a los 21 minutos "55": 0.20, # 20% a los 55 minutos "144": 0.15, # 15% a las 2.4 horas "377": 0.10, # 10% a las 6+ horas "610": 0.05, # 5% después de 10 horas (hold largo) } stoploss = -0.15 # ANTI-TRADING: Permite fluctuaciones para capturar movimientos MASIVOS trailing_stop = True trailing_stop_positive = 0.0236 # Fibonacci 23.6% trailing_stop_positive_offset = 0.0382 # Fibonacci 38.2% trailing_only_offset_is_reached = True use_custom_stoploss = True # CRITICAL: Activar stoploss dimensional # ==================== PARÁMETROS CUÁNTICOS EVOLUTIVOS ==================== # Ángulos de resonancia cuántica resonance_angle_min = DecimalParameter(15.0, 35.0, default=23.6, space="buy", optimize=True) resonance_angle_max = DecimalParameter(45.0, 85.0, default=61.8, space="buy", optimize=True) # Thresholds de inteligencia colaborativa meta_consciousness_weight = DecimalParameter(0.15, 0.35, default=0.236, space="buy", optimize=True) strategic_brain_weight = DecimalParameter(0.10, 0.25, default=0.144, space="buy", optimize=True) risk_brain_weight = DecimalParameter(0.20, 0.40, default=0.309, space="buy", optimize=True) # Resonancia cuántica multinivel quantum_resonance_base = DecimalParameter(0.382, 0.786, default=0.618, space="buy", optimize=True) quantum_coherence_min = DecimalParameter(0.50, 0.85, default=0.72, space="buy", optimize=True) consciousness_flow_min = DecimalParameter(0.55, 0.88, default=0.68, space="buy", optimize=True) # Parámetros evolutivos evolution_learning_rate = DecimalParameter(0.05, 0.20, default=0.089, space="buy", optimize=True) collaborative_consensus_threshold = DecimalParameter(0.60, 0.90, default=0.764, space="buy", optimize=True) # Salidas cuánticas dissonance_angle = DecimalParameter(120.0, 170.0, default=137.5, space="sell", optimize=True) consciousness_decay_threshold = DecimalParameter(0.20, 0.45, default=0.309, space="sell", optimize=True) # URLs del Stack QBTC-UNIFIED QBTC_STACK = { 'leonardo_master': 'http://localhost:14001', 'metaconsciencia': 'http://localhost:14020', 'strategic_brain': 'http://localhost:14030', 'risk_brain': 'http://localhost:14031', 'operational_brain': 'http://localhost:14032', 'evolution_brain': 'http://localhost:14033', 'interbrain_comm': 'http://localhost:14034', 'collaborative_engine': 'http://localhost:14035', 'testing_framework': 'http://localhost:14036', 'kernel': 'http://localhost:14050', 'guardian': 'http://localhost:14600', 'portfolio': 'http://localhost:14300', 'metrics': 'http://localhost:14702', 'dashboard': 'http://localhost:14401' } # PERSONALIDADES CUÁNTICAS POR ACTIVO (Ingeniería Inversa) ASSET_QUANTUM_PERSONALITIES = { 'BTC/USDT': { 'type': 'plasma_quantum', 'volatility_factor': 1.4, # Más volátil 'consciousness_threshold_adj': +0.08, # Más estricto 'angle_noise_filter': 0.85, # Filtro de ruido 'circuit_breaker_sensitivity': 3 # Después de 3 pérdidas consecutivas }, 'ETH/USDT': { 'type': 'water_quantum', 'volatility_factor': 1.2, # Fluido 'consciousness_threshold_adj': +0.04, 'angle_noise_filter': 0.78, 'circuit_breaker_sensitivity': 4 }, 'BNB/USDT': { 'type': 'gold_quantum', 'volatility_factor': 0.9, # Más estable 'consciousness_threshold_adj': -0.02, # Más permisivo 'angle_noise_filter': 0.72, 'circuit_breaker_sensitivity': 5 # Más tolerante }, 'SOL/USDT': { 'type': 'mercury_quantum', 'volatility_factor': 1.3, # Ágil pero riesgoso 'consciousness_threshold_adj': +0.06, 'angle_noise_filter': 0.80, 'circuit_breaker_sensitivity': 3 # Rápido circuit breaker } } # ==================== MERKABA PROTOCOL & DIMENSIONAL ACCESS ==================== MERKABA_STRUCTURE = { 'tetrahedron_male': { 'rotation': 'clockwise', 'polarity': 'positive', 'energy': 'yang', 'element': 'fire' }, 'tetrahedron_female': { 'rotation': 'counter_clockwise', 'polarity': 'negative', 'energy': 'yin', 'element': 'water' }, 'optimal_rotation_speed': 21, # 21 RPS para máxima eficiencia 'light_field_intensity': 0.618, # Proporción áurea 'consciousness_required': 0.618 # Umbral mínimo } # DIMENSIONAL ACCESS LEVELS DIMENSIONAL_MULTIPLIERS = { 3: {'name': 'Physical Reality', 'multiplier': 1.00, 'consciousness_req': 0.30, 'risk_factor': 1.00}, 4: {'name': 'Time Manipulation', 'multiplier': 1.34, 'consciousness_req': 0.50, 'risk_factor': 0.85}, 5: {'name': 'Probability Waves', 'multiplier': 1.618, 'consciousness_req': 0.65, 'risk_factor': 0.72}, 6: {'name': 'Pure Consciousness', 'multiplier': 2.00, 'consciousness_req': 0.78, 'risk_factor': 0.60}, 7: {'name': 'Divine Abundance', 'multiplier': 2.618, 'consciousness_req': 0.85, 'risk_factor': 0.45} } # SACRED GEOMETRY MULTIPLIERS SACRED_GEOMETRY_MULTIPLIERS = { 'flower_of_life': {'effect': 'harmonic_resonance', 'multiplier': 1.15, 'dimensions': [4, 5, 6]}, 'sri_yantra': {'effect': 'abundance_manifestation', 'multiplier': 1.25, 'dimensions': [6, 7, 8]}, 'metatrons_cube': {'effect': 'dimensional_stability', 'multiplier': 1.10, 'dimensions': [5, 6, 7]}, 'golden_spiral': {'effect': 'fibonacci_growth', 'multiplier': 1.618, 'dimensions': [5, 7, 9]}, 'platonic_solids': {'effect': 'elemental_balance', 'multiplier': 1.20, 'dimensions': [4, 5, 6, 7]}, 'torus_field': {'effect': 'energy_circulation', 'multiplier': 1.30, 'dimensions': [6, 7, 8]} } def __init__(self, config: dict) -> None: super().__init__(config) self.logger = logging.getLogger(__name__) # Cache para servicios QBTC self._qbtc_cache = {} self._cache_timeout = 30 # 30 segundos # Estado evolutivo self._evolution_state = { 'learning_cycles': 0, 'successful_patterns': [], 'risk_adjustments': 0 } # Estado dimensional y Merkaba self._dimensional_state = { 'current_dimension': 3, # Comenzamos en 3D 'consciousness_level': 0.618, # Nivel inicial 'merkaba_rotation_speed': 0, 'active_geometries': ['golden_spiral'], # Geometría base 'dimensional_multiplier': 1.0, 'risk_adjustment_factor': 1.0 } # Estado ZEN Anti-Trading (Máximo 1 trade perfecto por día) self._anti_trading_state = { 'last_trade_date': None, # Fecha del último trade 'daily_trade_count': 0, # Contador diario 'rejection_counter': 0, # Oportunidades rechazadas 'enlightenment_level': 0.0, # Nivel de iluminación (aumenta con rechazos) 'universal_resistance': 0.01, # TESTING: Resistencia universal REDUCIDA 'perfect_moment_detector': 0.0 # Score del momento perfecto actual } # REACTOR DE ANTIMATERIA CUÁNTICO self._antimatter_reactor = { 'matter_charge': 0.0, # Carga del sistema MATERIA (long) 'antimatter_charge': 0.0, # Carga del sistema ANTIMATERIA (anti-long) 'containment_field': 1.0, # Campo de contención (evita aniquilación prematura) 'annihilation_threshold': 0.65, # TESTING: Umbral REDUCIDO para aniquilaciones excepcionales 'energy_accumulator': 0.0, # Acumulador de energía pre-explosión 'reactor_temperature': 0.0, # Temperatura del reactor (0=frío, 1=fusión) 'particle_collision_detected': False, # Estado de colisión 'vacuum_energy_level': 0.0, # Energía del vacío cuántico 'quantum_superposition': True, # Estado de superposición cuántica 'last_annihilation_date': None # Control de explosiones } # ==================== INTEGRACIÓN CON STACK QBTC ==================== def get_qbtc_service(self, service_name: str, endpoint: str = '/health', timeout: int = 2) -> dict: """ Obtiene datos de servicios QBTC con cache inteligente y fallback """ cache_key = f"{service_name}_{endpoint}" now = datetime.now().timestamp() # Verificar cache if cache_key in self._qbtc_cache: cached_data, timestamp = self._qbtc_cache[cache_key] if now - timestamp < self._cache_timeout: return cached_data try: if service_name not in self.QBTC_STACK: return {} url = f"{self.QBTC_STACK[service_name]}{endpoint}" response = requests.get(url, timeout=timeout) if response.status_code == 200: data = response.json() self._qbtc_cache[cache_key] = (data, now) return data else: return {} except Exception as e: self.logger.debug(f"Service {service_name} unavailable: {e}") return {} def get_metaconsciencia_decision(self) -> dict: """Obtiene decisión de MetaConsciencia""" data = self.get_qbtc_service('metaconsciencia', '/health') if data and 'decisión' in data: return data['decisión'] return {'accion': 'HOLD', 'confianza': 0.5, 'razon': 'servicio no disponible'} def get_quantum_state(self) -> dict: """Obtiene estado cuántico del kernel""" data = self.get_qbtc_service('kernel', '/health') if data and 'quantum_state' in data: return data['quantum_state'] return { 'resonance_level': 0.5, 'consciousness_level': 0.5, 'coherence_level': 0.5, 'quantum_flow': 'NORMAL' } def get_strategic_analysis(self) -> dict: """Obtiene análisis del Strategic Brain""" data = self.get_qbtc_service('strategic_brain', '/strategy') if data: return data return {'recommendation': 'NEUTRAL', 'confidence': 0.5} def get_risk_assessment(self) -> dict: """Obtiene evaluación de riesgo""" data = self.get_qbtc_service('risk_brain', '/risk-assessment') if data: return data return {'risk_level': 'MEDIUM', 'risk_score': 0.5} def get_collaborative_decision(self) -> dict: """Obtiene decisión colaborativa del engine""" data = self.get_qbtc_service('collaborative_engine', '/api/decision') if data: return data return {'consensus': 'NEUTRAL', 'confidence': 0.5, 'votes': {}} def get_portfolio_state(self) -> dict: """Obtiene estado del portfolio""" data = self.get_qbtc_service('portfolio', '/portfolio') if data: return data return {'balance': 10000, 'positions': [], 'risk_utilization': 0.0} # ==================== DIMENSIONAL ACCESS METHODS ==================== def calculate_consciousness_level(self, dataframe: DataFrame) -> float: """Calcula el nivel de consciencia actual basado en métricas cuánticas""" try: # Factores base de consciencia quantum_resonance = dataframe['quantum_resonance'].iloc[-1] if 'quantum_resonance' in dataframe.columns else 0.5 quantum_coherence = dataframe['quantum_coherence'].iloc[-1] if 'quantum_coherence' in dataframe.columns else 0.5 consciousness_flow = dataframe['consciousness_flow'].iloc[-1] if 'consciousness_flow' in dataframe.columns else 0.5 # Factores de servicios QBTC meta_decision = self.get_metaconsciencia_decision() meta_confidence = meta_decision.get('confianza', 0.5) quantum_state = self.get_quantum_state() kernel_consciousness = quantum_state.get('consciousness_level', 0.5) # Cálculo de consciencia multidimensional consciousness_level = ( quantum_resonance * 0.25 + quantum_coherence * 0.25 + consciousness_flow * 0.20 + meta_confidence * 0.15 + kernel_consciousness * 0.15 ) return min(max(consciousness_level, 0.0), 1.0) except Exception: return 0.618 # Nivel seguro por defecto def activate_merkaba(self, consciousness_level: float) -> dict: """Activa el protocolo Merkaba según el nivel de consciencia""" try: if consciousness_level < 0.30: rotation_speed = 0 status = 'dormant' elif consciousness_level < 0.45: rotation_speed = 3.33 status = 'awakening' elif consciousness_level < 0.618: rotation_speed = 11.11 status = 'activation' elif consciousness_level < 0.75: rotation_speed = 21.00 status = 'harmonization' elif consciousness_level < 0.87: rotation_speed = 33.33 status = 'transcendence' elif consciousness_level < 0.94: rotation_speed = 55.55 status = 'mastery' else: rotation_speed = 108.00 status = 'unity' self._dimensional_state['merkaba_rotation_speed'] = rotation_speed return { 'status': status, 'rotation_speed': rotation_speed, 'light_field_intensity': consciousness_level * 0.618, 'dimensional_access': self.get_accessible_dimensions(consciousness_level) } except Exception: return {'status': 'dormant', 'rotation_speed': 0, 'dimensional_access': [3]} def get_accessible_dimensions(self, consciousness_level: float) -> list: """Determina qué dimensiones son accesibles según el nivel de consciencia""" accessible = [3] # Siempre accesible 3D for dimension, config in self.DIMENSIONAL_MULTIPLIERS.items(): if consciousness_level >= config['consciousness_req']: accessible.append(dimension) return sorted(accessible) def calculate_dimensional_multiplier(self, consciousness_level: float, active_geometries: list) -> float: """Calcula el multiplicador dimensional total""" try: # Obtener dimensión más alta accesible accessible_dims = self.get_accessible_dimensions(consciousness_level) highest_dim = max(accessible_dims) # Multiplicador base dimensional base_multiplier = self.DIMENSIONAL_MULTIPLIERS[highest_dim]['multiplier'] # Bonus de consciencia consciousness_bonus = consciousness_level * 0.5 # Multiplicadores de geometría sagrada geometry_bonus = 1.0 for geometry in active_geometries: if geometry in self.SACRED_GEOMETRY_MULTIPLIERS: geo_config = self.SACRED_GEOMETRY_MULTIPLIERS[geometry] if highest_dim in geo_config['dimensions']: geometry_bonus *= geo_config['multiplier'] total_multiplier = base_multiplier * (1 + consciousness_bonus) * geometry_bonus # Actualizar estado dimensional self._dimensional_state['current_dimension'] = highest_dim self._dimensional_state['consciousness_level'] = consciousness_level self._dimensional_state['dimensional_multiplier'] = total_multiplier return total_multiplier except Exception: return 1.0 # Multiplier seguro por defecto def calculate_dimensional_risk_adjustment(self, consciousness_level: float) -> float: """Calcula el ajuste de riesgo dimensional""" try: accessible_dims = self.get_accessible_dimensions(consciousness_level) highest_dim = max(accessible_dims) risk_factor = self.DIMENSIONAL_MULTIPLIERS[highest_dim]['risk_factor'] # En dimensiones superiores, el riesgo disminuye self._dimensional_state['risk_adjustment_factor'] = risk_factor return risk_factor except Exception: return 1.0 # ==================== INTELIGENCIA ORGÁNICA ADAPTATIVA ==================== def detect_market_quantum_phase(self, dataframe: DataFrame) -> str: """Detecta la fase cuántica del mercado para ajustar sensibilidad dimensional""" try: # Calcular dirección del mercado en múltiples timeframes market_momentum_short = (dataframe['close'].iloc[-8:].mean() / dataframe['close'].iloc[-16:-8].mean() - 1) * 100 market_momentum_medium = (dataframe['close'].iloc[-21:].mean() / dataframe['close'].iloc[-42:-21].mean() - 1) * 100 market_momentum_long = (dataframe['close'].iloc[-55:].mean() / dataframe['close'].iloc[-110:-55].mean() - 1) * 100 # Pesos fibonacci para múltiples timeframes combined_momentum = (market_momentum_short * 0.618 + market_momentum_medium * 0.236 + market_momentum_long * 0.146) # Determinar fase cuántica if combined_momentum > 2.0: return 'bull' elif combined_momentum < -2.0: return 'bear' else: return 'neutral' except Exception: return 'neutral' def apply_asset_quantum_personality(self, pair: str, base_consciousness_threshold: float) -> float: """Aplica la personalidad cuántica específica del activo""" if pair in self.ASSET_QUANTUM_PERSONALITIES: personality = self.ASSET_QUANTUM_PERSONALITIES[pair] adjusted_threshold = base_consciousness_threshold + personality['consciousness_threshold_adj'] # Verificar circuit breaker if pair in self._organic_state['asset_circuit_breakers']: adjusted_threshold += 0.10 # Threshold más estricto si hay circuit breaker return max(0.5, min(0.95, adjusted_threshold)) # Limits de seguridad return base_consciousness_threshold def calculate_matter_charge(self, dataframe: DataFrame) -> float: """Sistema MATERIA - Calcula carga positiva para LONG""" try: # Factores que FAVORECEN compra (materia) matter_factors = 0.0 # Factor 1: Consciencia alta = materia positiva consciousness = dataframe['consciousness_level'].iloc[-1] matter_factors += min(consciousness * 2, 1.0) # Factor 2: Resonancia cuántica = energía de materia resonance = dataframe['enhanced_quantum_resonance'].iloc[-1] matter_factors += min(resonance * 1.5, 1.0) # Factor 3: Momentum positivo = aceleración de partícula momentum = dataframe['angular_momentum'].iloc[-1] if momentum > 0: matter_factors += min(momentum * 3, 1.0) # Factor 4: Tendencia alcista = campo magnético positivo if dataframe['ema8'].iloc[-1] > dataframe['ema21'].iloc[-1]: matter_factors += 0.3 # Factor 5: RSI en zona de compra (30-70) rsi = dataframe['rsi'].iloc[-1] if 30 <= rsi <= 70: matter_factors += 0.2 # Normalizar a 0-1 return min(matter_factors / 4.0, 1.0) except Exception: return 0.0 def calculate_antimatter_charge(self, dataframe: DataFrame) -> float: """Sistema ANTIMATERIA - Calcula carga negativa CONTRA LONG""" try: # Factores que RECHAZAN compra (antimateria) antimatter_factors = 0.0 # Factor 1: Consciencia baja = antimateria consciousness = dataframe['consciousness_level'].iloc[-1] if consciousness < 0.5: antimatter_factors += (0.5 - consciousness) * 4 # Factor 2: Coherencia baja = caos cuántico coherence = dataframe['quantum_coherence'].iloc[-1] if coherence < 0.6: antimatter_factors += (0.6 - coherence) * 2 # Factor 3: Momentum negativo = antipartícula momentum = dataframe['angular_momentum'].iloc[-1] if momentum < 0: antimatter_factors += abs(momentum) * 3 # Factor 4: Tendencia bajista = campo antimagnético if dataframe['ema8'].iloc[-1] < dataframe['ema21'].iloc[-1]: antimatter_factors += 0.4 # Factor 5: RSI extremo = inestabilidad cuántica rsi = dataframe['rsi'].iloc[-1] if rsi > 80 or rsi < 20: antimatter_factors += 0.3 # Factor 6: Volumen bajo = ausencia de energía if dataframe['volume_ratio_fast'].iloc[-1] < 0.8: antimatter_factors += 0.2 # Normalizar a 0-1 return min(antimatter_factors / 4.0, 1.0) except Exception: return 0.0 def detect_particle_collision(self, dataframe: DataFrame, pair: str) -> dict: """DETECTOR DE COLISIÓN DE PARTÍCULAS - Momento de aniquilación""" try: current_date = datetime.now().date() # PASO 1: Calcular cargas de materia y antimateria matter_charge = self.calculate_matter_charge(dataframe) antimatter_charge = self.calculate_antimatter_charge(dataframe) # Actualizar estado del reactor self._antimatter_reactor['matter_charge'] = matter_charge self._antimatter_reactor['antimatter_charge'] = antimatter_charge # PASO 2: Calcular equilibrio entre fuerzas opuestas # Ambas cargas deben ser ALTAS y EQUILIBRADAS para colisión charge_balance = 1.0 - abs(matter_charge - antimatter_charge) minimum_energy = min(matter_charge, antimatter_charge) # PASO 3: Campo de contención (evita aniquilación prematura) containment_integrity = 1.0 if minimum_energy < 0.7: # Energía insuficiente containment_integrity = 1.0 # Mantener contención elif charge_balance < 0.8: # Desequilibrio peligroso containment_integrity = 1.0 # Mantener contención else: # Condiciones óptimas - reducir contención gradualmente containment_integrity = max(0.0, 1.0 - (minimum_energy * charge_balance)) self._antimatter_reactor['containment_field'] = containment_integrity # PASO 4: Detector de colisión collision_probability = minimum_energy * charge_balance * (1.0 - containment_integrity) self._antimatter_reactor['reactor_temperature'] = collision_probability # PASO 5: Umbral de aniquilación (TESTING EXTREMO) annihilation_ready = ( collision_probability >= self._antimatter_reactor['annihilation_threshold'] and minimum_energy >= 0.3 and # TESTING: Muy reducido charge_balance >= 0.5 and # TESTING: Muy reducido containment_integrity < 0.8 and # TESTING: Muy permisivo (self._antimatter_reactor['last_annihilation_date'] != current_date) # No aniquilado hoy ) # DEBUG: Logging detallado del reactor cada 4 horas para BTC if pair == 'BTC/USDT' and len(dataframe) > 0: current_time = dataframe.index[-1] if current_time.hour % 4 == 0 and current_time.minute == 0: logger.info(f"🔬 REACTOR ANTIMATERIA [{pair}] @ {current_time}:") logger.info(f" Matter: {matter_charge:.3f} | Antimatter: {antimatter_charge:.3f}") logger.info(f" Min Energy: {minimum_energy:.3f} ({'✅' if minimum_energy >= 0.75 else '❌'})") logger.info(f" Balance: {charge_balance:.3f} ({'✅' if charge_balance >= 0.85 else '❌'})") logger.info(f" Containment: {containment_integrity:.3f} ({'✅' if containment_integrity < 0.2 else '❌'})") logger.info(f" Collision Prob: {collision_probability:.3f} / {self._antimatter_reactor['annihilation_threshold']}") logger.info(f" 💥 ANNIHILATION READY: {'YES! 🚀' if annihilation_ready else 'NO'}") # PASO 6: Calcular energía de explosión (E=mc²) explosion_energy = 0.0 if annihilation_ready: # Energía liberada = suma de masas * velocidad de la luz al cuadrado (metafóricamente) mass_energy = (matter_charge + antimatter_charge) / 2.0 speed_of_light_squared = collision_probability ** 2 explosion_energy = mass_energy * speed_of_light_squared * 10.0 # Factor de amplificación # Marcar aniquilación ejecutada self._antimatter_reactor['last_annihilation_date'] = current_date self._antimatter_reactor['particle_collision_detected'] = True self._antimatter_reactor['energy_accumulator'] = explosion_energy return { 'annihilation_ready': annihilation_ready, 'matter_charge': matter_charge, 'antimatter_charge': antimatter_charge, 'charge_balance': charge_balance, 'collision_probability': collision_probability, 'explosion_energy': explosion_energy, 'containment_field': containment_integrity } except Exception: return { 'annihilation_ready': False, 'matter_charge': 0.0, 'antimatter_charge': 0.0, 'charge_balance': 0.0, 'collision_probability': 0.0, 'explosion_energy': 0.0, 'containment_field': 1.0 } def detect_zen_anti_trading_mode(self, dataframe: DataFrame) -> bool: """ ZEN ANTI-TRADING MODE: Solo el momento PERFECTO supera la resistencia universal Máximo 1 trade por día - La mayoría de oportunidades se rechazan para lograr perfección """ try: current_date = datetime.now().date() # REGLA 1: MÁXIMO 1 TRADE POR DÍA GLOBAL if (self._anti_trading_state['last_trade_date'] == current_date or self._anti_trading_state['daily_trade_count'] >= 1): return False # YA operamos hoy, ZEN MODE # REGLA 2: INCREMENTAR RESISTENCIA con cada oportunidad rechazada self._anti_trading_state['rejection_counter'] += 1 enlightenment_boost = min(0.1, self._anti_trading_state['rejection_counter'] * 0.001) self._anti_trading_state['enlightenment_level'] += enlightenment_boost # REGLA 3: MOMENTO PERFECTO = Todas las dimensiones alineadas PERFECTAMENTE perfect_conditions = 0 total_conditions = 10 # Condición 1: Consciencia EXTREMA (>0.75 - TESTING) if dataframe['consciousness_level'].iloc[-1] > 0.75: perfect_conditions += 1 # Condición 2: Multiplicador dimensional ALTO (>2.0 - TESTING) if dataframe['dimensional_multiplier'].iloc[-1] > 2.0: perfect_conditions += 1 # Condición 3: Resonancia cuántica PERFECTA (>0.80 - TESTING) if dataframe['enhanced_quantum_resonance'].iloc[-1] > 0.80: perfect_conditions += 1 # Condición 4: Coherencia ABSOLUTA (>0.75 - TESTING) if dataframe['quantum_coherence'].iloc[-1] > 0.75: perfect_conditions += 1 # Condición 5: Flow de consciencia SUPREMO (>0.80 - TESTING) if dataframe['enhanced_consciousness_flow'].iloc[-1] > 0.80: perfect_conditions += 1 # Condición 6: Momentum angular PERFECTO (>0.6 - TESTING) if dataframe['angular_momentum'].iloc[-1] > 0.6: perfect_conditions += 1 # Condición 7: Confluencia dorada SUPREMA (>0.75 - TESTING) if dataframe['golden_confluence'].iloc[-1] > 0.75: perfect_conditions += 1 # Condición 8: RSI en zona dorada EXACTA (55-65) rsi_val = dataframe['rsi'].iloc[-1] if 55 <= rsi_val <= 65: perfect_conditions += 1 # Condición 9: Volumen ELEVADO (>1.5x promedio - TESTING) if dataframe['volume_ratio_fast'].iloc[-1] > 1.5: perfect_conditions += 1 # Condición 10: Precio en posición de poder (entre EMA21 y EMA8) close_price = dataframe['close'].iloc[-1] ema8 = dataframe['ema8'].iloc[-1] ema21 = dataframe['ema21'].iloc[-1] if ema21 < close_price < ema8: perfect_conditions += 1 # MOMENTO PERFECTO = 7/10 condiciones (TESTING) perfection_ratio = perfect_conditions / total_conditions self._anti_trading_state['perfect_moment_detector'] = perfection_ratio # TESTING EXTREMO: Reducir a 4/10 condiciones perfectas is_perfect_moment = (perfection_ratio >= 0.4 and self._anti_trading_state['enlightenment_level'] >= self._anti_trading_state['universal_resistance']) if is_perfect_moment: # RESET del sistema para próxima oportunidad self._anti_trading_state['daily_trade_count'] = 1 self._anti_trading_state['last_trade_date'] = current_date self._anti_trading_state['rejection_counter'] = 0 self._anti_trading_state['enlightenment_level'] = 0.0 return True return False # Rechazar - No es momento perfecto except Exception: return False # En caso de error, NO operar (principio de precaución) def update_asset_performance_tracking(self, pair: str, is_winning_trade: bool): """Actualiza tracking de performance por activo para circuit breakers""" if pair not in self._organic_state['asset_consecutive_losses']: self._organic_state['asset_consecutive_losses'][pair] = 0 if is_winning_trade: self._organic_state['asset_consecutive_losses'][pair] = 0 # Remover circuit breaker si existía if pair in self._organic_state['asset_circuit_breakers']: del self._organic_state['asset_circuit_breakers'][pair] else: self._organic_state['asset_consecutive_losses'][pair] += 1 # Activar circuit breaker si es necesario if pair in self.ASSET_QUANTUM_PERSONALITIES: sensitivity = self.ASSET_QUANTUM_PERSONALITIES[pair]['circuit_breaker_sensitivity'] if self._organic_state['asset_consecutive_losses'][pair] >= sensitivity: self._organic_state['asset_circuit_breakers'][pair] = True def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime, current_rate: float, current_profit: float, **kwargs) -> float: """ Stoploss cuántico dimensional MEJORADO - Adaptativo con multiplicadores y tiempo """ try: # Obtener estados dimensionales actuales consciousness_level = self._dimensional_state.get('consciousness_level', 0.618) risk_adjustment = self._dimensional_state.get('risk_adjustment_factor', 1.0) dimensional_multiplier = self._dimensional_state.get('dimensional_multiplier', 1.0) current_dimension = self._dimensional_state.get('current_dimension', 3) # Stoploss base con factor golden ratio base_stoploss = -0.0618 # Ajuste por dimensión y multiplicador (más multiplicador = menos riesgo) dimensional_protection = 1.0 / (1.0 + (dimensional_multiplier - 1.0) * 0.3) # Reduce riesgo con mayor multiplicador dimensional_stoploss = base_stoploss * risk_adjustment * dimensional_protection # TRAILING CUÁNTICO ADAPTATIVO (Ingeniería Inversa) trade_duration_minutes = (current_time - trade.open_date_utc).total_seconds() / 60 # Ajuste temporal con personalidad del activo time_protection = 1.0 if pair in self.ASSET_QUANTUM_PERSONALITIES: volatility_factor = self.ASSET_QUANTUM_PERSONALITIES[pair]['volatility_factor'] # Activos más volátiles necesitan trailing más rápido time_multiplier = 1.0 / volatility_factor time_protection = min(1.0 + (trade_duration_minutes / (60 * time_multiplier)) * 0.1, 1.5) else: time_protection = min(1.0 + (trade_duration_minutes / 60) * 0.1, 1.5) # Protección por nivel de consciencia (MEJORADA) if consciousness_level >= 0.85: # 7D Divine Abundance consciousness_protection = 0.40 # Protección máxima elif consciousness_level >= 0.78: # 6D Pure Consciousness consciousness_protection = 0.55 # Protección alta elif consciousness_level >= 0.65: # 5D Probability Waves consciousness_protection = 0.70 # Protección media elif consciousness_level >= 0.50: # 4D Time Manipulation consciousness_protection = 0.82 # Protección básica else: consciousness_protection = 0.95 # Protección mínima # PROTECCIÓN CUÁNTICA POR GANANCIA + CONSCIOUSNESS DECAY profit_protection = 1.0 consciousness_decay_protection = 1.0 # Si la consciencia actual es mucho menor que cuando se abrió, ser más agresivo if consciousness_level < 0.65: # Consciencia baja consciousness_decay_protection = 0.75 elif consciousness_level < 0.55: # Consciencia muy baja consciousness_decay_protection = 0.60 if current_profit > 0.02: # 2%+ ganancia profit_protection = 0.7 # Trailing stop más agresivo elif current_profit > 0.01: # 1%+ ganancia profit_protection = 0.85 # STOPLOSS FINAL con todas las protecciones ORGÁNICAS final_stoploss = (dimensional_stoploss * consciousness_protection * profit_protection * time_protection * consciousness_decay_protection) # Límites de seguridad final_stoploss = max(final_stoploss, -0.15) # No más del 15% pérdida final_stoploss = min(final_stoploss, -0.01) # Mínimo 1% protección return final_stoploss except Exception: return -0.0618 # Stoploss seguro por defecto # ==================== INDICADORES CUÁNTICOS EVOLUTIVOS ==================== def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ Indicadores cuánticos con integración completa del stack QBTC """ # === INDICADORES TÉCNICOS BASE CON PERÍODOS FIBONACCI === dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14) dataframe['rsi_21'] = ta.RSI(dataframe, timeperiod=21) dataframe['rsi_34'] = ta.RSI(dataframe, timeperiod=34) dataframe['rsi_55'] = ta.RSI(dataframe, timeperiod=55) # MACD con períodos fibonacci optimizados macd = ta.MACD(dataframe, fastperiod=8, slowperiod=21, signalperiod=13) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] # EMAs en secuencia fibonacci completa for period in [5, 8, 13, 21, 34, 55, 89, 144]: dataframe[f'ema{period}'] = ta.EMA(dataframe, timeperiod=period) # Bollinger Bands con desviación phi bb = ta.BBANDS(dataframe, timeperiod=21, nbdevup=self.PHI, nbdevdn=self.PHI) dataframe['bb_upper'] = bb['upperband'] dataframe['bb_middle'] = bb['middleband'] dataframe['bb_lower'] = bb['lowerband'] # Stochastic con períodos sagrados stoch = ta.STOCH(dataframe, fastk_period=14, slowk_period=3, slowd_period=3) dataframe['stoch_k'] = stoch['slowk'] dataframe['stoch_d'] = stoch['slowd'] # Williams %R y CCI dataframe['willr'] = ta.WILLR(dataframe, timeperiod=21) dataframe['cci'] = ta.CCI(dataframe, timeperiod=21) # === VOLUMEN CON ANÁLISIS FIBONACCI === for period in [8, 13, 21, 34, 55]: dataframe[f'volume_ema{period}'] = ta.EMA(dataframe['volume'], timeperiod=period) dataframe['volume_ratio_fast'] = dataframe['volume'] / dataframe['volume_ema8'] dataframe['volume_ratio_medium'] = dataframe['volume'] / dataframe['volume_ema21'] dataframe['volume_ratio_slow'] = dataframe['volume'] / dataframe['volume_ema55'] # === INDICADORES CUÁNTICOS EVOLUTIVOS === # 1. Price Vector Angles Avanzado dataframe['price_vector_angles'] = self.calculate_advanced_price_vectors(dataframe) # 2. Quantum Resonance Multinivel dataframe['quantum_resonance'] = self.calculate_quantum_resonance_advanced(dataframe) # 3. Angular Momentum con Fibonacci Weights dataframe['angular_momentum'] = self.calculate_angular_momentum_advanced(dataframe) # 4. Coherencia Cuántica Multidimensional dataframe['quantum_coherence'] = self.calculate_quantum_coherence_advanced(dataframe) # 5. Golden Ratio Confluence Zones dataframe['golden_confluence'] = self.calculate_golden_confluence_advanced(dataframe) # 6. Consciousness Flow (integración con servicios QBTC) dataframe['consciousness_flow'] = self.calculate_consciousness_flow(dataframe) # 7. Collaborative Intelligence Score dataframe['collaborative_score'] = self.calculate_collaborative_intelligence(dataframe) # 8. Evolution Learning Score dataframe['evolution_score'] = self.calculate_evolution_learning(dataframe) # === DIMENSIONAL ENHANCEMENTS === # 9. Consciousness Level Calculation (CORREGIDO - sin recursión) latest_consciousness = self.calculate_consciousness_level(dataframe) dataframe['consciousness_level'] = latest_consciousness # 10. Merkaba Activation State dataframe['merkaba_status'] = dataframe['consciousness_level'].apply( lambda level: self.activate_merkaba(level)['status'] ) # 11. Dimensional Multiplier dataframe['dimensional_multiplier'] = dataframe['consciousness_level'].apply( lambda level: self.calculate_dimensional_multiplier(level, self._dimensional_state['active_geometries']) ) # 12. Risk Adjustment Factor dataframe['risk_adjustment'] = dataframe['consciousness_level'].apply( self.calculate_dimensional_risk_adjustment ) # 13. Enhanced Quantum Metrics with Dimensional Amplification dataframe['enhanced_quantum_resonance'] = ( dataframe['quantum_resonance'] * dataframe['dimensional_multiplier'] ).ewm(span=8).mean() dataframe['enhanced_consciousness_flow'] = ( dataframe['consciousness_flow'] * dataframe['dimensional_multiplier'] ).ewm(span=13).mean() return dataframe def calculate_advanced_price_vectors(self, dataframe: DataFrame) -> pd.Series: """Cálculo avanzado de vectores de precio con múltiples timeframes""" try: angles_series = [] # Períodos fibonacci para vectores periods = [5, 8, 13, 21, 34] for period in periods: price_change = dataframe['close'].pct_change(periods=period) # Convertir a ángulos con normalización mejorada angle = np.arctan(price_change * 100) * 180 / np.pi + 90 angles_series.append(angle) # Promedio ponderado con pesos fibonacci weights = [0.233, 0.233, 0.233, 0.189, 0.112] # Suman 1.0 combined_angle = sum(angle * weight for angle, weight in zip(angles_series, weights)) # Aplicar resonancia con ángulos sagrados resonance_factor = self.apply_sacred_resonance(combined_angle) return (combined_angle * resonance_factor).fillna(90) except Exception: return pd.Series([90] * len(dataframe), index=dataframe.index) def apply_sacred_resonance(self, angles: pd.Series) -> pd.Series: """Aplica factor de resonancia basado en ángulos sagrados""" try: resonance_factors = [] for angle in angles: if pd.isna(angle): resonance_factors.append(1.0) continue # Buscar resonancia con ángulos sagrados min_distance = float('inf') for sacred_angle in self.SACRED_ANGLES + self.FIBONACCI_ANGLES: distance = abs(angle - sacred_angle) min_distance = min(min_distance, distance) # Factor de resonancia inversamente proporcional a distancia if min_distance <= 2.0: resonance = 1.2 # Fuerte resonancia elif min_distance <= 5.0: resonance = 1.1 # Resonancia media elif min_distance <= 10.0: resonance = 1.05 # Resonancia leve else: resonance = 1.0 # Sin resonancia # Bonus especial para Golden Angle if abs(angle - self.PHI_ANGLE) <= 1.5: resonance *= 1.15 resonance_factors.append(resonance) return pd.Series(resonance_factors, index=angles.index) except Exception: return pd.Series([1.0] * len(angles), index=angles.index) def calculate_quantum_resonance_advanced(self, dataframe: DataFrame) -> pd.Series: """Resonancia cuántica avanzada con integración QBTC""" try: # Resonancia base de ángulos base_resonance = self.calculate_angle_resonance(dataframe['price_vector_angles']) # Factor de kernel cuántico quantum_state = self.get_quantum_state() kernel_factor = quantum_state.get('resonance_level', 0.5) # Factor de metaconsciencia meta_decision = self.get_metaconsciencia_decision() meta_factor = meta_decision.get('confianza', 0.5) # Resonancia combinada con pesos fibonacci combined_resonance = ( base_resonance * 0.618 + # Golden ratio peso kernel_factor * 0.236 + # Fibonacci peso meta_factor * 0.146 # Fibonacci peso ) return combined_resonance.ewm(span=13).mean() except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_angle_resonance(self, angles: pd.Series) -> pd.Series: """Calcula resonancia basada en proximidad a ángulos fibonacci""" try: resonance_scores = [] for angle in angles: if pd.isna(angle): resonance_scores.append(0.618) continue # Distancias a ángulos fibonacci distances = [abs(angle - fib_angle) for fib_angle in self.FIBONACCI_ANGLES] min_distance = min(distances) # Scoring basado en distancia if min_distance <= 3.0: score = 0.95 elif min_distance <= 7.0: score = 0.80 elif min_distance <= 15.0: score = 0.65 else: score = 0.45 # Bonus para golden angle if abs(angle - self.PHI_ANGLE) <= 2.0: score *= 1.1 resonance_scores.append(min(score, 1.0)) return pd.Series(resonance_scores, index=angles.index) except Exception: return pd.Series([0.618] * len(angles), index=angles.index) def calculate_angular_momentum_advanced(self, dataframe: DataFrame) -> pd.Series: """Momentum angular avanzado con machine learning""" try: angles = dataframe['price_vector_angles'] # Velocidad angular en diferentes escalas fibonacci velocity_5 = angles.diff(periods=5) velocity_8 = angles.diff(periods=8) velocity_13 = angles.diff(periods=13) # Aceleración angular acceleration = velocity_8.diff(periods=5) # Momentum combinado con pesos evolutivos momentum = ( velocity_5 * 0.382 + # Fibonacci weight velocity_8 * 0.236 + # Fibonacci weight velocity_13 * 0.146 + # Fibonacci weight acceleration * 0.236 # Fibonacci weight ) # Normalización sigmoidal mejorada normalized = 2 / (1 + np.exp(-momentum/15)) - 1 return normalized.ewm(span=8).mean().fillna(0) except Exception: return pd.Series([0.0] * len(dataframe), index=dataframe.index) def calculate_quantum_coherence_advanced(self, dataframe: DataFrame) -> pd.Series: """Coherencia cuántica multidimensional""" try: # Coherencia de EMAs con períodos fibonacci ema_coherence = self.calculate_ema_coherence(dataframe) # Coherencia de RSI en múltiples timeframes rsi_coherence = self.calculate_rsi_coherence(dataframe) # Coherencia de volumen volume_coherence = self.calculate_volume_coherence(dataframe) # Factor de coherencia del kernel quantum_state = self.get_quantum_state() kernel_coherence = quantum_state.get('coherence_level', 0.5) # Coherencia combinada total_coherence = ( ema_coherence * 0.309 + # Fibonacci rsi_coherence * 0.236 + # Fibonacci volume_coherence * 0.146 + # Fibonacci kernel_coherence * 0.309 # Fibonacci ) return total_coherence.ewm(span=21).mean() except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_ema_coherence(self, dataframe: DataFrame) -> pd.Series: """Coherencia entre EMAs fibonacci - CORREGIDO para evitar RuntimeWarnings""" try: # Verificar que tenemos suficientes datos if len(dataframe) < 10: return pd.Series([0.618] * len(dataframe), index=dataframe.index) # Ángulos entre EMAs consecutivas angles = [] ema_pairs = [(8, 13), (13, 21), (21, 34), (34, 55), (55, 89)] for fast, slow in ema_pairs: # Evitar división por cero y usar valores pequeños como epsilon denominator = dataframe[f'ema{slow}'].replace(0, 1e-10) angle = np.arctan((dataframe[f'ema{fast}'] - dataframe[f'ema{slow}']) / denominator) * 180 / np.pi angle = angle.fillna(0) # Llenar NaN con 0 angles.append(angle) # Solo calcular std si tenemos múltiples valores válidos if not angles: return pd.Series([0.618] * len(dataframe), index=dataframe.index) angles_matrix = np.column_stack(angles) # Calcular std con manejo seguro de casos edge coherence_values = [] for i in range(len(angles_matrix)): row = angles_matrix[i] valid_values = row[~np.isnan(row)] if len(valid_values) > 1: # Necesitamos al menos 2 valores para std std_dev = np.std(valid_values) coherence = 1 / (1 + std_dev / 5) else: coherence = 0.618 # Valor por defecto coherence_values.append(coherence) return pd.Series(coherence_values, index=dataframe.index) except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_rsi_coherence(self, dataframe: DataFrame) -> pd.Series: """Coherencia entre RSIs de diferentes períodos - CORREGIDO""" try: if len(dataframe) < 10: return pd.Series([0.618] * len(dataframe), index=dataframe.index) rsi_values = [dataframe['rsi'].fillna(50), dataframe['rsi_21'].fillna(50), dataframe['rsi_34'].fillna(50), dataframe['rsi_55'].fillna(50)] # Calcular coherencia fila por fila para evitar problemas coherence_values = [] for i in range(len(dataframe)): row_values = [rsi_val.iloc[i] for rsi_val in rsi_values] valid_values = [v for v in row_values if not np.isnan(v)] if len(valid_values) > 1: std_dev = np.std(valid_values) coherence = 1 / (1 + std_dev / 20) else: coherence = 0.618 coherence_values.append(coherence) return pd.Series(coherence_values, index=dataframe.index) except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_volume_coherence(self, dataframe: DataFrame) -> pd.Series: """Coherencia de patrones de volumen - CORREGIDO""" try: if len(dataframe) < 10: return pd.Series([0.618] * len(dataframe), index=dataframe.index) volume_ratios = [ dataframe['volume_ratio_fast'].fillna(1.0), dataframe['volume_ratio_medium'].fillna(1.0), dataframe['volume_ratio_slow'].fillna(1.0) ] # Calcular coherencia fila por fila para evitar problemas coherence_values = [] for i in range(len(dataframe)): row_values = [ratio.iloc[i] for ratio in volume_ratios] valid_values = [v for v in row_values if not np.isnan(v) and v != 0] if len(valid_values) > 1: std_dev = np.std(valid_values) coherence = 1 / (1 + std_dev / 2) else: coherence = 0.618 coherence_values.append(coherence) return pd.Series(coherence_values, index=dataframe.index) except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_golden_confluence_advanced(self, dataframe: DataFrame) -> pd.Series: """Confluencia golden ratio avanzada con múltiples marcos""" try: confluence_scores = [] for period in [21, 34, 55]: high_period = dataframe['high'].rolling(window=period).max() low_period = dataframe['low'].rolling(window=period).min() range_period = high_period - low_period # Niveles fibonacci del rango levels = [] for fib_ratio in [0.236, 0.382, 0.500, 0.618, 0.786]: level = low_period + range_period * fib_ratio levels.append(level) # Distancia mínima del precio actual a niveles current_price = dataframe['close'] distances = [abs(current_price - level) / current_price for level in levels] min_distance = pd.concat(distances, axis=1).min(axis=1) confluence_scores.append(1 / (1 + min_distance * 100)) # Promedio ponderado de confluencias weights = [0.382, 0.382, 0.236] # Fibonacci weights total_confluence = sum(score * weight for score, weight in zip(confluence_scores, weights)) return total_confluence.ewm(span=13).mean() except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_consciousness_flow(self, dataframe: DataFrame) -> pd.Series: """Flujo de consciencia integrado con servicios QBTC""" try: # Estado cuántico del kernel quantum_state = self.get_quantum_state() consciousness_level = quantum_state.get('consciousness_level', 0.5) # Flujo base de consciencia técnica technical_flow = ( (dataframe['rsi'] / 100) * 0.25 + ((dataframe['macd'] > dataframe['macdsignal']).astype(int)) * 0.25 + (dataframe['volume_ratio_fast'] / 3) * 0.25 + (dataframe['quantum_coherence']) * 0.25 ) # Factor de metaconsciencia meta_decision = self.get_metaconsciencia_decision() meta_confidence = meta_decision.get('confianza', 0.5) # Flujo combinado consciousness_flow = ( technical_flow * 0.618 + # Golden ratio consciousness_level * 0.236 + # Fibonacci meta_confidence * 0.146 # Fibonacci ) return pd.Series(consciousness_flow).ewm(span=21).mean() except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_collaborative_intelligence(self, dataframe: DataFrame) -> pd.Series: """Inteligencia colaborativa de todos los cerebros""" try: # Puntuaciones base técnicas base_score = ( dataframe['quantum_resonance'] * 0.25 + dataframe['quantum_coherence'] * 0.25 + dataframe['angular_momentum'].apply(lambda x: (x + 1) / 2) * 0.25 + # Normalize [-1,1] to [0,1] dataframe['golden_confluence'] * 0.25 ) # Factores de cerebros especializados strategic_data = self.get_strategic_analysis() strategic_factor = strategic_data.get('confidence', 0.5) risk_data = self.get_risk_assessment() risk_factor = 1.0 - (risk_data.get('risk_score', 0.5)) # Invertir riesgo collaborative_data = self.get_collaborative_decision() collaborative_factor = collaborative_data.get('confidence', 0.5) # Score colaborativo final collaborative_score = ( base_score * 0.5 + # Base técnico strategic_factor * 0.2 + # Strategic brain risk_factor * 0.2 + # Risk brain collaborative_factor * 0.1 # Collaborative engine ) return pd.Series(collaborative_score).ewm(span=13).mean() except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) def calculate_evolution_learning(self, dataframe: DataFrame) -> pd.Series: """Score de aprendizaje evolutivo""" try: # Score base que evoluciona con el tiempo evolution_base = 0.5 # Ajuste basado en ciclos de aprendizaje if self._evolution_state['learning_cycles'] > 0: success_rate = len(self._evolution_state['successful_patterns']) / self._evolution_state['learning_cycles'] evolution_base += (success_rate - 0.5) * 0.2 # Ajuste gradual # Factor de evolución del brain evolution_data = self.get_qbtc_service('evolution_brain', '/evolution') evolution_factor = evolution_data.get('learning_score', 0.5) if evolution_data else 0.5 # Score evolutivo combinado evolution_score = ( evolution_base * 0.618 + # Base evolutivo evolution_factor * 0.382 # Evolution brain ) return pd.Series([evolution_score] * len(dataframe), index=dataframe.index) except Exception: return pd.Series([0.618] * len(dataframe), index=dataframe.index) # ==================== LÓGICA DE ENTRADA ELITE ==================== def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ 💫 REACTOR DE ANTIMATERIA CUÁNTICO - Aniquilación Controlada para Energía Pura 💫 """ pair = metadata['pair'] # PASO 1: DETECTOR DE COLISIÓN DE PARTÍCULAS collision_data = self.detect_particle_collision(dataframe, pair) # PASO 2: VERIFICAR ANIQUILACIÓN POTENCIAL if not collision_data['annihilation_ready']: # Reactor en contención - NO operar dataframe.loc[:, 'enter_long'] = 0 # Log del estado del reactor solo si hay actividad significativa collision_prob = collision_data['collision_probability'] if collision_prob > 0.5: matter = collision_data['matter_charge'] antimatter = collision_data['antimatter_charge'] balance = collision_data['charge_balance'] containment = collision_data['containment_field'] self.logger.info(f"ANTIMATTER REACTOR: {pair} | Matter={matter:.3f}, Antimatter={antimatter:.3f}, " f"Balance={balance:.3f}, Collision={collision_prob:.3f}, Containment={containment:.3f}") return dataframe # PASO 3: ANIQUILACIÓN DETECTADA - Verificar con ZEN DETECTOR self.logger.info(f"☄️ ANTIMATTER ANNIHILATION POTENTIAL: {pair} - Checking ZEN validation...") # PASO 4: ZEN ANTI-TRADING DETECTOR (filtro final ultra-selectivo) zen_approved = self.detect_zen_anti_trading_mode(dataframe) if not zen_approved: # La aniquilación fue bloqueada por ZEN mode - Resistir la tentación dataframe.loc[:, 'enter_long'] = 0 self.logger.info(f"☔ ZEN BLOCK: {pair} - Annihilation resisted for perfect moment") return dataframe # PASO 5: ¡💫 ANIQUILACIÓN APROBADA! - LIBERAR ENERGÍA PURA 💫 self.logger.error(f"☢️ ANTIMATTER ANNIHILATION APPROVED! {pair} - MASSIVE ENERGY RELEASE! ☢️") # En aniquilación aprobada, generar entrada únicamente en la última vela annihilation_entry = pd.Series([False] * len(dataframe), index=dataframe.index) annihilation_entry.iloc[-1] = True # Solo última vela # TAG de aniquilación dataframe.loc[annihilation_entry, 'enter_tag'] = 'ZEN_ANTIMATTER_ANNIHILATION' dataframe.loc[annihilation_entry, 'enter_long'] = 1 # Log de aniquilación controlada exitosa matter = collision_data['matter_charge'] antimatter = collision_data['antimatter_charge'] explosion_energy = collision_data['explosion_energy'] balance = collision_data['charge_balance'] self.logger.error(f"🔥 ZEN ANNIHILATION EXECUTED: {pair} | Matter={matter:.3f}, Antimatter={antimatter:.3f}, " f"Balance={balance:.3f}, EXPLOSION_ENERGY={explosion_energy:.3f}E+10, " f"Perfect_Moment_Score={self._anti_trading_state['perfect_moment_detector']:.3f} 🔥") return dataframe # ========== CONDICIONES OBSOLETAS (YA NO USADAS) ========== # 1. Resonancia Cuántica Enhanced (con multiplicadores dimensionales) quantum_condition = ( dataframe['enhanced_quantum_resonance'] >= self.quantum_resonance_base.value ) # 2. Coherencia Multidimensional MEJORADA (ajustada por consciencia y dimensión) coherence_condition = ( (dataframe['quantum_coherence'] * dataframe['consciousness_level'] * (dataframe['dimensional_multiplier'] / 2.0)) >= (self.quantum_coherence_min.value * 0.65) # REDUCIDO 0.8 -> 0.65 ) # 3. Ángulos de Resonancia Dimensional ESPECÍFICOS (Optimizados por camino) # Rangos específicos para cada dimensión angles = dataframe['price_vector_angles'] multiplier = dataframe['dimensional_multiplier'] # Elite6D: Ángulos cuanticos puros (resonancia dimensional alta) elite6d_angle_condition = ( (angles >= (self.resonance_angle_min.value * 0.5)) & # 11.8° (angles <= (self.resonance_angle_max.value * 2.2)) & # 135.96° (más amplio para 6D) (multiplier >= 1.8) # Elite6D requiere multiplicador alto ) # Merkaba4D: Ángulos clásicos fibonacci merkaba4d_angle_condition = ( (angles >= (self.resonance_angle_min.value * 0.8)) & # 18.88° (angles <= (self.resonance_angle_max.value * 1.6)) & # 98.88° (multiplier >= 1.1) # 4D básico ) # Quantum4D: Ángulos precisos de resonancia quantum4d_angle_condition = ( (angles >= (self.resonance_angle_min.value * 0.7)) & # 16.52° (angles <= (self.resonance_angle_max.value * 1.4)) & # 86.52° (multiplier >= 1.25) # Quantum requiere más precisión ) # Sacred Geometry: Ángulos amplios para geometría sagrada sacred_angle_condition = ( (angles >= (self.resonance_angle_min.value * 0.4)) & # 9.44° (angles <= (self.resonance_angle_max.value * 2.5)) & # 154.5° (muy amplio) (multiplier >= 1.15) # Sacred geometry flexible ) # 4. Flujo de Consciencia Enhanced (multidimensional) consciousness_condition = ( dataframe['enhanced_consciousness_flow'] >= (self.consciousness_flow_min.value * 0.8) ) # 5. Inteligencia Colaborativa Dimensional collaborative_condition = ( (dataframe['collaborative_score'] * dataframe['dimensional_multiplier']) >= self.collaborative_consensus_threshold.value ) # 6. Merkaba Activation Condition (nuevo) merkaba_condition = ( dataframe['consciousness_level'] >= 0.50 # Mínimo para 4D ) # ========== CONDICIONES DE SERVICIOS QBTC ========== # MetaConsciencia: Decisión positiva meta_decision = self.get_metaconsciencia_decision() meta_condition = pd.Series([meta_decision.get('accion', 'HOLD') in ['BUY', 'STRONG_BUY']] * len(dataframe), index=dataframe.index) meta_confidence = pd.Series([meta_decision.get('confianza', 0) >= 0.7] * len(dataframe), index=dataframe.index) # Kernel: Estado cuántico favorable quantum_state = self.get_quantum_state() kernel_condition = pd.Series([ quantum_state.get('quantum_flow', 'NORMAL') in ['HIGH', 'NORMAL'] and quantum_state.get('resonance_level', 0) >= 0.6 ] * len(dataframe), index=dataframe.index) # Strategic Brain: Análisis favorable strategic_data = self.get_strategic_analysis() strategic_condition = pd.Series([strategic_data.get('recommendation', 'NEUTRAL') in ['BUY', 'STRONG_BUY']] * len(dataframe), index=dataframe.index) # Risk Brain: Riesgo aceptable risk_data = self.get_risk_assessment() risk_condition = pd.Series([risk_data.get('risk_level', 'HIGH') in ['LOW', 'MEDIUM']] * len(dataframe), index=dataframe.index) # Guardian: Sin alertas críticas guardian_data = self.get_qbtc_service('guardian', '/health') guardian_condition = pd.Series([guardian_data.get('status', 'ERROR') == 'OK'] * len(dataframe), index=dataframe.index) # Portfolio: Capacidad disponible portfolio_data = self.get_portfolio_state() portfolio_condition = pd.Series([portfolio_data.get('risk_utilization', 1.0) < 0.8] * len(dataframe), index=dataframe.index) # ========== CONDICIONES TÉCNICAS DE SOPORTE ========== # Confirmación técnica DIMENSIONAL (Optimizada para armonía cuántica) # Condiciones técnicas que escalan con consciencia y dimensión consciousness_adjusted_rsi = ( (dataframe['rsi'] >= (25 - dataframe['consciousness_level'] * 5)) & # RSI min adaptativo (dataframe['rsi'] <= (75 + dataframe['consciousness_level'] * 10)) # RSI max adaptativo ) dimensional_macd = ( (dataframe['macd'] > dataframe['macdsignal']) | ((dataframe['dimensional_multiplier'] > 2.0) & (dataframe['macdhist'] > -0.001)) # Relajado para alta dimensión ) quantum_volume = ( (dataframe['volume_ratio_fast'] > (0.8 + dataframe['consciousness_level'] * 0.3)) & # Volumen adaptativo (dataframe['volume_ratio_medium'] > 0.9) ) dimensional_trend = ( (dataframe['ema8'] > dataframe['ema21']) | # Tendencia clásica ((dataframe['consciousness_level'] > 0.75) & (dataframe['ema5'] > dataframe['ema13'])) # Elite6D más sensible ) technical_condition = ( consciousness_adjusted_rsi & dimensional_macd & quantum_volume & dimensional_trend ) # Momentum angular positivo momentum_condition = dataframe['angular_momentum'] > -0.2 # Confluencia golden ratio favorable confluence_condition = dataframe['golden_confluence'] > 0.5 # ========== CAMINOS DIMENSIONALES DE ENTRADA ========== # APLICAR PERSONALIDAD CUÁNTICA ESPECÍFICA DEL ACTIVO pair = metadata['pair'] base_consciousness_threshold = 0.72 consciousness_threshold = self.apply_asset_quantum_personality(pair, base_consciousness_threshold) # AJUSTE DIMENSIONAL SEGÚN FASE DEL MERCADO market_phase_adjustment = 0.0 if market_phase == 'bull': market_phase_adjustment = -0.05 # Más agresivo en mercados alcistas elif market_phase == 'bear': market_phase_adjustment = +0.03 # Más conservador en mercados bajistas final_consciousness_threshold = max(0.50, consciousness_threshold + market_phase_adjustment) # Camino 1: DIMENSIONAL ELITE (6D+) - CON PERSONALIDAD CUÁNTICA ADAPTATIVA path_dimensional_elite = ( (dataframe['consciousness_level'] >= final_consciousness_threshold) & # ADAPTATIVO POR ACTIVO (dataframe['dimensional_multiplier'] >= 1.6) & # Base dimensional (dataframe['enhanced_quantum_resonance'] >= 0.58) & # Base resonancia (dataframe['quantum_coherence'] >= 0.55) & # Base coherencia elite6d_angle_condition & # Ángulos ESPECÍFICOS Elite6D (dataframe['enhanced_consciousness_flow'] >= 0.55) & # Base flow technical_condition & # Condición técnica dimensional momentum_condition # Momentum básico ) # Camino 2: MERKABA GOLDEN (4D-5D) - Activación Merkaba (MAS ACCESIBLE) path_merkaba_golden = ( merkaba_condition & # Mínimo 4D acceso (dataframe['enhanced_quantum_resonance'] > self.quantum_resonance_base.value) & # SIN SUMA, sólo base (dataframe['golden_confluence'] > 0.45) & # REDUCIDO de confluence_condition merkaba4d_angle_condition & # Ángulos ESPECÍFICOS Merkaba4D # meta_condition & # REMOVIDO para mayor accesibilidad # kernel_condition & # REMOVIDO para mayor accesibilidad # risk_condition & # REMOVIDO para mayor accesibilidad technical_condition # Solo condición técnica ) # Camino 3: CONSCIOUSNESS COLLABORATIVE (5D) - Consciencia + colaboración (OPTIMIZADO) path_consciousness_collaborative = ( (dataframe['consciousness_level'] >= 0.58) & # REDUCIDO de 0.62 a 0.58 para activación (dataframe['enhanced_consciousness_flow'] > (self.consciousness_flow_min.value * 0.6)) & # REDUCIDO 0.7 a 0.6 collaborative_condition & meta_confidence & strategic_condition & guardian_condition & technical_condition ) # Camino 4: QUANTUM RESONANCE (4D+) - Resonancia cuántica (MÁS ACCESIBLE) path_quantum_resonance = ( (dataframe['enhanced_quantum_resonance'] > 0.55) & # REDUCIDO 0.62 -> 0.55 (dataframe['dimensional_multiplier'] >= 1.20) & # REDUCIDO 1.25 -> 1.20 quantum4d_angle_condition & # Ángulos ESPECÍFICOS Quantum4D # coherence_condition & # REMOVIDO para accesibilidad # kernel_condition & # REMOVIDO para accesibilidad (dataframe['angular_momentum'] > 0.0) & # MÁS flexible 0.05 -> 0.0 technical_condition ) # Camino 5: SACRED GEOMETRY (MENOS DOMINANTE) - Geometría sagrada básica path_sacred_geometry = ( (dataframe['dimensional_multiplier'] >= 1.10) & # REDUCIDO 1.15 -> 1.10 (dataframe['golden_confluence'] > 0.55) & # AUMENTADO 0.50 -> 0.55 (menos dominante) sacred_angle_condition & # Ángulos ESPECÍFICOS Sacred technical_condition & (dataframe['angular_momentum'] > -0.1) # MÁS restrictivo que momentum_condition ) # ENTRADA FINAL CON TAGS DIMENSIONALES - cualquier camino dimensional válido entry_condition = ( path_dimensional_elite | path_merkaba_golden | path_consciousness_collaborative | path_quantum_resonance | path_sacred_geometry ) # APLICAR TAGS DIMENSIONALES CON PRIORIDAD (el último tag sobrescribe) # Orden de prioridad: Sacred -> Quantum4D -> Conscious5D -> Merkaba4D -> Elite6D dataframe.loc[path_sacred_geometry, 'enter_tag'] = 'Sacred' dataframe.loc[path_quantum_resonance, 'enter_tag'] = 'Quantum4D' dataframe.loc[path_consciousness_collaborative, 'enter_tag'] = 'Conscious5D' dataframe.loc[path_merkaba_golden, 'enter_tag'] = 'Merkaba4D' dataframe.loc[path_dimensional_elite, 'enter_tag'] = 'Elite6D' # MÁXIMA PRIORIDAD # DEBUG DETALLADO - Identificar problema dimensional if entry_condition.any(): current_consciousness = dataframe['consciousness_level'].iloc[-1] if len(dataframe) > 0 else 0.618 current_dimension = self._dimensional_state.get('current_dimension', 3) current_multiplier = dataframe['dimensional_multiplier'].iloc[-1] if len(dataframe) > 0 else 1.0 # Debug EXHAUSTIVO de cada condición Elite6D if path_dimensional_elite.sum() == 0 and current_consciousness > 0.75: last_idx = len(dataframe) - 1 consciousness_ok = dataframe['consciousness_level'].iloc[last_idx] >= 0.75 multiplier_ok = dataframe['dimensional_multiplier'].iloc[last_idx] >= 1.8 enhanced_quantum_ok = dataframe['enhanced_quantum_resonance'].iloc[last_idx] >= 0.65 coherence_ok = dataframe['quantum_coherence'].iloc[last_idx] >= 0.65 current_angle = dataframe['price_vector_angles'].iloc[last_idx] current_multiplier_check = dataframe['dimensional_multiplier'].iloc[last_idx] # Usar rangos ESPECÍFICOS Elite6D min_angle = self.resonance_angle_min.value * 0.5 # 11.8° max_angle = self.resonance_angle_max.value * 2.2 # 135.96° angle_ok = ((current_angle >= min_angle) and (current_angle <= max_angle) and (current_multiplier_check >= 1.8)) # Elite6D requiere multiplicador alto enhanced_flow_ok = dataframe['enhanced_consciousness_flow'].iloc[last_idx] >= 0.60 technical_ok = ( (dataframe['rsi'].iloc[last_idx] >= 25) and (dataframe['rsi'].iloc[last_idx] <= 70) and (dataframe['macd'].iloc[last_idx] > dataframe['macdsignal'].iloc[last_idx]) and (dataframe['volume_ratio_fast'].iloc[last_idx] > 1.0) and (dataframe['ema8'].iloc[last_idx] > dataframe['ema21'].iloc[last_idx]) ) momentum_ok = dataframe['angular_momentum'].iloc[last_idx] > -0.2 self.logger.warning(f"ELITE6D DEBUG - Consciousness({consciousness_ok})={current_consciousness:.3f}, " f"Multiplier({multiplier_ok})={current_multiplier:.3f}, " f"EnhancedQuantum({enhanced_quantum_ok}), Coherence({coherence_ok}), " f"Angle({angle_ok}) [{current_angle:.1f} in {min_angle:.1f}-{max_angle:.1f}], EnhancedFlow({enhanced_flow_ok}), " f"Technical({technical_ok}), Momentum({momentum_ok})") self.logger.info(f"QBTC DIMENSIONAL Entry: Elite6D={path_dimensional_elite.sum()}, " f"Merkaba4D={path_merkaba_golden.sum()}, Conscious5D={path_consciousness_collaborative.sum()}, " f"Quantum4D={path_quantum_resonance.sum()}, Sacred={path_sacred_geometry.sum()} | " f"Consciousness: {current_consciousness:.3f}, Dimension: {current_dimension}D, " f"Multiplier: {current_multiplier:.3f}x") # APLICAR ENTRADA CON TRACKING ORGÁNICO if entry_condition.any(): # Agregar timestamp de señal al buffer de densidad self._organic_state['signal_density_buffer'].append(datetime.now()) # Log de estado orgánico actual current_consciousness = dataframe['consciousness_level'].iloc[-1] if len(dataframe) > 0 else 0.618 current_dimension = self._dimensional_state.get('current_dimension', 3) current_multiplier = dataframe['dimensional_multiplier'].iloc[-1] if len(dataframe) > 0 else 1.0 self.logger.info(f"QBTC ORGANIC Entry: {pair} | Phase={market_phase}, " f"Consciousness={current_consciousness:.3f} (threshold={final_consciousness_threshold:.3f}), " f"Dimension={current_dimension}D, Multiplier={current_multiplier:.3f}x, " f"Elite6D={path_dimensional_elite.sum()}, Merkaba4D={path_merkaba_golden.sum()}, " f"Conscious5D={path_consciousness_collaborative.sum()}, Quantum4D={path_quantum_resonance.sum()}, " f"Sacred={path_sacred_geometry.sum()}, StressLevel={self._organic_state['system_stress_level']:.2f}") dataframe.loc[entry_condition, 'enter_long'] = 1 return dataframe # ==================== LÓGICA DE SALIDA ELITE ==================== def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ ZEN EXIT: Solo salir cuando la PERFECCIÓN se desvanece completamente """ # PRINCIPIO: Si entramos en momento PERFECTO, solo salir cuando sea IMPERFECTO # Calcular nivel de IMPERFECCIÓN actual current_consciousness = dataframe['consciousness_level'].iloc[-1] if len(dataframe) > 0 else 0.0 current_coherence = dataframe['quantum_coherence'].iloc[-1] if len(dataframe) > 0 else 0.0 current_resonance = dataframe['enhanced_quantum_resonance'].iloc[-1] if len(dataframe) > 0 else 0.0 current_flow = dataframe['enhanced_consciousness_flow'].iloc[-1] if len(dataframe) > 0 else 0.0 # Imperfección = Promedio de condiciones deterioradas imperfection_level = 1.0 - ((current_consciousness + current_coherence + current_resonance + current_flow) / 4.0) # SALIR solo si la imperfección es SEVERA (>70%) severe_imperfection = imperfection_level > 0.7 # O si RSI está en zona de pánico/euforia extrema rsi_extreme = (dataframe['rsi'] > 85) | (dataframe['rsi'] < 15) # Condición de salida ZEN zen_exit_condition = severe_imperfection | rsi_extreme if zen_exit_condition.any(): self.logger.info(f"ZEN EXIT: {metadata['pair']} | Imperfection={imperfection_level:.3f}, " f"Consciousness={current_consciousness:.3f}, RSI={dataframe['rsi'].iloc[-1]:.1f}") dataframe.loc[zen_exit_condition, 'exit_long'] = 1 return dataframe # ========== CONDICIONES DE SALIDA CUÁNTICAS ========== # 1. Disonancia Angular angle_exit = ( dataframe['price_vector_angles'] > self.dissonance_angle.value ) # 2. Pérdida de Resonancia Cuántica resonance_exit = ( dataframe['quantum_resonance'] < (self.quantum_resonance_base.value - 0.2) ) # 3. Decay de Consciencia consciousness_exit = ( dataframe['consciousness_flow'] < self.consciousness_decay_threshold.value ) # 4. Pérdida de Coherencia Multidimensional coherence_exit = ( dataframe['quantum_coherence'] < (self.quantum_coherence_min.value - 0.15) ) # 5. Momentum Angular Negativo Fuerte momentum_exit = dataframe['angular_momentum'] < -0.5 # ========== SALIDAS DE SERVICIOS QBTC ========== # MetaConsciencia: Decisión de venta meta_decision = self.get_metaconsciencia_decision() meta_exit = pd.Series([meta_decision.get('accion', 'HOLD') in ['SELL', 'STRONG_SELL']] * len(dataframe), index=dataframe.index) # Strategic Brain: Recomendación de salida strategic_data = self.get_strategic_analysis() strategic_exit = pd.Series([strategic_data.get('recommendation', 'NEUTRAL') in ['SELL', 'STRONG_SELL']] * len(dataframe), index=dataframe.index) # Risk Brain: Riesgo alto risk_data = self.get_risk_assessment() risk_exit = pd.Series([risk_data.get('risk_level', 'LOW') in ['HIGH', 'CRITICAL']] * len(dataframe), index=dataframe.index) # Guardian: Alerta de safety-kill guardian_data = self.get_qbtc_service('guardian', '/health') guardian_exit = pd.Series([guardian_data.get('alert_level', 'NONE') in ['HIGH', 'CRITICAL']] * len(dataframe), index=dataframe.index) # Collaborative Engine: Consenso de venta collaborative_data = self.get_collaborative_decision() collaborative_exit = pd.Series([collaborative_data.get('consensus', 'NEUTRAL') in ['SELL', 'STRONG_SELL']] * len(dataframe), index=dataframe.index) # ========== SALIDAS TÉCNICAS ========== # RSI sobrecomprado severo rsi_exit = (dataframe['rsi'] > 80) | (dataframe['rsi_21'] > 85) # MACD divergencia bajista macd_exit = ( (dataframe['macd'] < dataframe['macdsignal']) & (dataframe['macdhist'] < dataframe['macdhist'].shift(1)) & (dataframe['rsi'] > 60) ) # Ruptura de tendencia principal trend_break = ( (dataframe['ema8'] < dataframe['ema21']) & (dataframe['ema21'] < dataframe['ema34']) & (dataframe['close'] < dataframe['ema13']) ) # Bollinger Bands: Precio por encima de banda superior bb_exit = dataframe['close'] > dataframe['bb_upper'] # ========== SALIDAS DE EMERGENCIA ========== # Portfolio: Límites de riesgo excedidos portfolio_data = self.get_portfolio_state() portfolio_emergency = pd.Series([portfolio_data.get('risk_utilization', 0) > 0.95] * len(dataframe), index=dataframe.index) # Kernel: Estado cuántico crítico quantum_state = self.get_quantum_state() kernel_emergency = pd.Series([quantum_state.get('quantum_flow', 'NORMAL') == 'CRITICAL'] * len(dataframe), index=dataframe.index) # ========== APLICACIÓN FINAL DE SALIDAS ========== # Salidas prioritarias (inmediatas) priority_exit = guardian_exit | portfolio_emergency | kernel_emergency # Salidas de servicios QBTC qbtc_exit = meta_exit | strategic_exit | risk_exit | collaborative_exit # Salidas cuánticas quantum_exit = angle_exit | resonance_exit | consciousness_exit | coherence_exit | momentum_exit # Salidas técnicas technical_exit = rsi_exit | macd_exit | trend_break | bb_exit # SALIDA FINAL - lógica priorizada exit_condition = ( priority_exit | # Máxima prioridad qbtc_exit | # Alta prioridad quantum_exit | # Media prioridad technical_exit # Baja prioridad ) # Log para debugging if exit_condition.any(): self.logger.info(f"QBTC Exit signals: Priority={priority_exit.sum()}, QBTC={qbtc_exit.sum()}, " f"Quantum={quantum_exit.sum()}, Technical={technical_exit.sum()}") dataframe.loc[exit_condition, 'exit_long'] = 1 return dataframe