Tcl_AsyncDelete...

[eagledj-design]

First Check

• I added a very descriptive title here.
• I have checked the FAQs for a similar question and didn't find it.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the NiceGUI documentation, with the integrated search.
• I already searched online "How to X in NiceGUI" and didn't find any information.

Example Code

# gui.py
"""
MasterBot GUI completo (integrado):
- Pestañas: Scalping, Trading, Estudio de Datos (gráfico grande en ventana separada),
  Descarga Histórico, Backtesting, Noticias, Binance
- Gráfico principal: usa mplfinance/matplotlib en una ventana nueva redimensionable.
- Actualización en tiempo real a través de WebSocket (Binance kline_1m).
Guarda como gui.py y ejecútalo desde la raíz del proyecto.
"""

import logging
import os
import sys
from threading import Thread
from datetime import datetime, timedelta
from decimal import Decimal
import json
import time
import traceback
import threading
import numpy as np

import pandas as pd
import requests
import websocket
import customtkinter as ctk
from tkinter import filedialog, messagebox, Toplevel
import tkinter as tk

# Plot libraries
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
import mplfinance as mpf
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.lines import Line2D
from mplfinance.original_flavor import candlestick_ohlc
from scipy.signal import savgol_filter

from apscheduler.schedulers.background import BackgroundScheduler

# Optional HtmlFrame for embedding Plotly HTML (not used here)
try:
    from tkinterweb import HtmlFrame
except Exception:
    HtmlFrame = None

# Try to import project modules; if any fail, provide graceful fallbacks for local testing.
try:
    from api.telegram_api import TelegramAPI
except Exception:
    class TelegramAPI:
        def send_message(self, *args, **kwargs):
            return None

try:
    from db.database import create_tables
except Exception:
    def create_tables():
        return None

try:
    from backtester import Backtester as BacktesterModule
except Exception:
    class BacktesterModule:
        def __init__(self, db=None, symbol=None):
            pass

try:
    from ml.trainer import train_model
except Exception:
    def train_model(df):
        return None, None

try:
    from api.binance_api import (
        get_binance_client,
        get_historic_candles,
        get_all_balances,
        place_market_order,
        place_oco_order,
    )
except Exception:
    # Fallback stubs
    def get_binance_client(testnet=False):
        return None
    def get_historic_candles(client, symbol, interval, **kwargs):
        return pd.DataFrame()
    def get_all_balances(client):
        return {}
    def place_market_order(client, symbol, side, quantity):
        return None
    def place_oco_order(client, symbol, side, quantity, price, stop_price, stop_limit_price):
        return None

try:
    from api.cryptopanic_api import get_crypto_news
except Exception:
    def get_crypto_news(*args, **kwargs):
        return []

try:
    from analysis.data_analyzer import calculate_rsi, calculate_macd, calculate_bollinger_bands
except Exception:
    def calculate_rsi(df, period=14):
        return pd.Series([50]*len(df), index=df.index)
    def calculate_macd(df, period_fast=12, period_slow=26, period_signal=9):
        return pd.Series([0]*len(df), index=df.index), pd.Series([0]*len(df), index=df.index)
    def calculate_bollinger_bands(df, period=20):
        sma = df['close'].rolling(window=period).mean()
        std = df['close'].rolling(window=period).std()
        return sma, sma + 2*std, sma - 2*std

try:
    from ml.predictor import MLPredictor
except Exception:
    class MLPredictor:
        def __init__(self):
            pass

try:
    from strategy.risk_manager import get_risk_parameters, calculate_position_size
except Exception:
    def get_risk_parameters(*args, **kwargs):
        return {}
    def calculate_position_size(*args, **kwargs):
        return Decimal('0')

try:
    from strategy.strategy_manager import optimize_strategy, get_available_strategies, rsi_strategy
except Exception:
    def optimize_strategy(*args, **kwargs):
        return None, None, None
    def get_available_strategies():
        return {}
    def rsi_strategy(df, params):
        # simple hold
        return pd.Series(['HOLD']*len(df), index=df.index)

try:
    from strategy.onchain_sentiment import get_market_sentiment
except Exception:
    def get_market_sentiment(sym):
        return 0.0

try:
    from trading_engine import save_model, load_model, calculate_tp_sl, get_account_balance, create_market_order
except Exception:
    def save_model(*args, **kwargs):
        return None
    def load_model(*args, **kwargs):
        return None
    def calculate_tp_sl(price, mode='neutral', custom_tp=None, custom_sl=None):
        # simple TP/SL example
        tp = price * (1 + (custom_tp if custom_tp is not None else 0.02))
        sl = price * (1 - (custom_sl if custom_sl is not None else 0.01))
        return float(tp), float(sl)
    def get_account_balance(asset):
        return Decimal('0')
    def create_market_order(*args, **kwargs):
        return None

try:
    import config
except Exception:
    config = None

# al principio, junto a otras imports de strategy
from strategy.pattern_detector import detect_patterns


    # -----------------------
    # START / STOP ANALYSIS
    # -----------------------
    def start_analysis(self, mode: str):
        """
        Si mode == 'study' abrimos la ventana grande y arrancamos websocket/scheduler as usual.
        """
        # Disable buttons briefly to avoid double clicks
        try:
            self.start_button_scalping.configure(state="disabled")
            self.start_button_trading.configure(state="disabled")
            self.start_button_study.configure(state="disabled")
            self.stop_button.configure(state="normal")
        except Exception:
            pass

        is_real_mode = self.real_mode_checkbox_binance.get() == 1

        # For 'study', create the study window in main thread then start data/ws
        if mode == "study":
            # Create StudyWindow only once
            if self.study_window is None:
                def create_study_window():
                    try:
                        self.study_window = StudyWindow(self)
                    except Exception as e:
                        self.log_event(f"Error abriendo ventana de estudio: {e}")
                        self.study_window = None

                self.after(0, create_study_window)
            # Start data fetching & websocket if not already started
            analysis_thread = Thread(target=self._start_analysis_thread, args=[mode, is_real_mode], daemon=True)
            analysis_thread.start()
        else:
            analysis_thread = Thread(target=self._start_analysis_thread, args=[mode, is_real_mode], daemon=True)
            analysis_thread.start()

    def study_window_closed(self):
        """Callback cuando la StudyWindow se cierra por el usuario"""
        self.study_window = None
        # re-enable start button
        try:
            self.start_button_study.configure(state="normal")
        except Exception:
            pass

    def _start_analysis_thread(self, mode, is_real_mode):
        """
        Carga datos iniciales y lanza websocket y scheduler. Ejecutado en hilo no-main, pero
        todas las operaciones de UI se hacen vía self.after.
        """
        try:
            client = get_binance_client(testnet=not is_real_mode)
            self.log_event("Cargando datos históricos iniciales para el gráfico...")

            # Pedimos 30 minutos de velas 1m como historial inicial (timestamp en ms)
            end_dt = datetime.utcnow()
            start_dt = end_dt - timedelta(minutes=30)
            start_str = str(int(start_dt.timestamp() * 1000))
            end_str = str(int(end_dt.timestamp() * 1000))

            historic_candles = get_historic_candles(
                client=client,
                symbol=self.current_symbol,
                interval='1m',
                start_str=start_str,
                end_str=end_str,
                limit=1000
            )

            if historic_candles is None or (hasattr(historic_candles, "empty") and historic_candles.empty):
                self.log_event("Error: No se pudo obtener el historial para el gráfico. Revisa el símbolo y la conexión.")
                self.after(0, self.stop_analysis)
                return

            # normalizar df y guardar en self.df
            if isinstance(historic_candles, pd.DataFrame):
                df = historic_candles.copy()
                if not isinstance(df.index, pd.DatetimeIndex):
                    if 'open_time' in df.columns:
                        df = df.reset_index().rename(columns={'open_time': 'timestamp'})
                        df['timestamp'] = pd.to_datetime(df['timestamp'])
                        df = df.set_index('timestamp')
                    elif 'time' in df.columns:
                        df['time'] = pd.to_datetime(df['time'])
                        df = df.set_index('time')
                self.df = df.iloc[-500:].copy()
            else:
                try:
                    df = pd.DataFrame(historic_candles)
                    if 'open_time' in df.columns:
                        df['open_time'] = pd.to_datetime(df['open_time'])
                        df = df.set_index('open_time')
                    elif 'time' in df.columns:
                        df['time'] = pd.to_datetime(df['time'])
                        df = df.set_index('time')
                    self.df = df.iloc[-500:].copy()
                except Exception:
                    self.df = pd.DataFrame()

            self.log_event("Datos históricos iniciales cargados. Iniciando WebSocket...")
            # request first draw in StudyWindow (if exists)
            self.after(0, lambda: self.update_charts_initial())

            # lanzar websocket (pasa is_real_mode)
            self.run_websocket_thread(is_real_mode)

            self.after(0, lambda: self.status_label.configure(text=f"Estado: Bot {mode} en ejecución", fg_color="green"))

            # scheduler jobs (safe to call from non-main)
            try:
                if not self.scheduler.running:
                    self.scheduler.add_job(self.fetch_and_send_news, 'interval', hours=1)
                    # check every minute for trading signals (1m candles)
                    self.scheduler.add_job(self.check_for_trading_signal, 'interval', minutes=1, args=[is_real_mode])
                    self.scheduler.start()
            except Exception as e:
                self.log_event(f"Error arrancando scheduler: {e}")

        except Exception as e:
            self.log_event(f"Error crítico al iniciar el bot: {e}\n{traceback.format_exc()}")
            self.after(0, self.stop_analysis)
            try:
                self.telegram_api.send_message(f"❌ Error al iniciar el bot: {e}")
            except Exception:
                pass

    # -----------------------
    # WEBSOCKET (hilo)
    # -----------------------
    def run_websocket_thread(self, is_real_mode=False):
        """Inicia WebSocketApp en thread separado; actualiza self.df y pide redraw vía self.after."""
        try:
            ws_url = "wss://stream.binance.com:9443/ws"
            symbol_stream = f"{self.current_symbol.lower()}@kline_1m"
            subscribe_message = {"method": "SUBSCRIBE", "params": [symbol_stream], "id": 1}

            def on_open(ws):
                self.log_event("✅ Conexión WebSocket abierta.")
                try:
                    ws.send(json.dumps(subscribe_message))
                except Exception as e:
                    self.log_event(f"Error enviando subscribe: {e}")

            def on_message(ws, message):
                try:
                    data = json.loads(message)
                    if data.get('e') == 'kline':
                        kline = data['k']
                        ts = kline['t']
                        is_closed = kline.get('x', False)
                        new_row = {
                            'timestamp': int(ts),
                            'open': float(kline['o']),
                            'high': float(kline['h']),
                            'low': float(kline['l']),
                            'close': float(kline['c']),
                            'volume': float(kline['v'])
                        }
                        new_df = pd.DataFrame([new_row])
                        new_df['time'] = pd.to_datetime(new_df['timestamp'], unit='ms')
                        new_df = new_df.set_index('time')

                    # actualizar self.df en memoria (no tocar widgets aquí)
                        try:
                            # proteger acceso concurrente al df si el lock está disponible
                            if getattr(self, '_df_lock', None):
                                with self._df_lock:
                                    if getattr(self, 'df', None) is None or self.df.empty:
                                        self.df = new_df
                                    else:
                                        last_idx = self.df.index[-1]
                                        if last_idx != new_df.index[-1]:
                                            self.df = pd.concat([self.df, new_df])
                                            # limitar tamaño para evitar memory leaks/lag
                                            self.df = self.df.iloc[-3000:]
                                        else:
                                            # actualizar vela en curso sin sobrescribir open
                                            self.df.at[last_idx, 'close'] = new_row['close']
                                            self.df.at[last_idx, 'volume'] = new_row['volume']
                                            self.df.at[last_idx, 'high'] = max(self.df.at[last_idx, 'high'], new_row['high'])
                                            self.df.at[last_idx, 'low'] = min(self.df.at[last_idx, 'low'], new_row['low'])
                            else:
                                # sin lock disponible, comportarse como antes (menos seguro)
                                if getattr(self, 'df', None) is None or self.df.empty:
                                    self.df = new_df
                                else:
                                    last_idx = self.df.index[-1]
                                    if last_idx != new_df.index[-1]:
                                        self.df = pd.concat([self.df, new_df])
                                        self.df = self.df.iloc[-3000:]
                                    else:
                                        self.df.at[last_idx, 'close'] = new_row['close']
                                        self.df.at[last_idx, 'volume'] = new_row['volume']
                                        self.df.at[last_idx, 'high'] = max(self.df.at[last_idx, 'high'], new_row['high'])
                                        self.df.at[last_idx, 'low'] = min(self.df.at[last_idx, 'low'], new_row['low'])
                        except Exception as e:
                            # nunca permitir que on_message explote; loguear el error
                            self.log_event(f"⚠️ Error actualizando df interno: {e}")
                            self.log_event(f"⚠️ Error actualizando df interno: {e}")

                    # solicitar redraw en hilo principal
                        try:
                            self.after(0, self.request_window_redraw)
                        except Exception:
                            pass

                    # log ligeramente (no muy frecuente para no spamear)
                        if is_closed:
                                                self.log_event(f"Vela 1m cerrada: {datetime.fromtimestamp(ts/1000).strftime('%Y-%m-%d %H:%M:%S')}")
                        else:
                            self.log_event(f"Vela 1m actualizada: {datetime.fromtimestamp(ts/1000).strftime('%H:%M:%S')}")
                except Exception as e:
                # captura cualquier error de parsing
                    self.log_event(f"⚠️ Error procesando mensaje WebSocket: {e}")

            def on_error(ws, error):
                self.log_event(f"❌ Error de WebSocket: {error}")

            # on_close se delega a método de instancia para cerrar bien
            self.close_requested = False
            self.ws = websocket.WebSocketApp(
                ws_url,
                on_open=on_open,
                on_message=on_message,
                on_error=on_error,
                on_close=lambda ws, code, msg: self.after(0, lambda: self.on_close(ws, code, msg))
            )

        # ejecutar en thread demonio
            self.ws_thread = Thread(target=self._ws_run_forever_safe, daemon=True)
            self.ws_thread.start()

        except Exception as e:
            self.log_event(f"Error arrancando WebSocket: {e}")


    def _ws_run_forever_safe(self):
        """Run_forever envuelto para capturar excepciones y reiniciar si hace falta."""
        try:
            if getattr(self, "ws", None):
                # tiempos de reconexión y ping pueden ir aquí
                self.ws.run_forever(ping_interval=30, ping_timeout=20)
        except Exception as e:
        # evitar que un crash en ws mate la app
            try:
                self.log_event(f"WebSocket thread error: {e}")
            except Exception:
                pass
        finally:
        # marcar que ws terminó
            try:
                self.after(0, lambda: self.on_close(None, None, None))
            except Exception:
                pass

    def on_close(self, ws, close_status_code, close_msg):
        """Limpieza segura cuando el websocket se cierra (ejecutarse en hilo principal vía after)."""
        try:
            self.log_event("🔌 Conexión WebSocket cerrada.")
        except Exception:
            pass

    # marcar petición de cierre para evitar reinicios automáticos
        self.close_requested = True

        if not self.close_requested:
            self.log_event("Reconectando Websocket tras cierre inesperado...")
            self.run_websocket_thread(is_real_mode=self.real_mode_checkbox_binance.get() == 1)

    # cerrar ws si existe
        try:
            if getattr(self, "ws", None):
                try:
                    self.ws.close()
                except Exception:
                    pass
                self.ws = None
        except Exception:
            pass

    # esperar thread
        try:
            if getattr(self, "ws_thread", None) and self.ws_thread.is_alive():
                self.ws_thread.join(timeout=1)
        except Exception:
            pass
        finally:
            self.ws_thread = None

    # opcional: detener scheduler aquí si quieres
        try:
            if hasattr(self, "scheduler") and self.scheduler and getattr(self.scheduler, "running", False):
                try:
                    self.scheduler.shutdown(wait=False)
                    self.log_event("⏹️ Scheduler detenido.")
                except Exception:
                    pass
        except Exception:
            pass

    # destruir ventana en hilo principal
        self.after(0, self.destroy)

    def on_exit(self):
        """Cierre ordenado de la aplicación: cerrar WS, detener scheduler y destruir ventana (ejecutable en main thread)."""
        try:
            self.log_event("🚪 Cerrando aplicación...")
        except Exception:
            pass

    # solicitar cierre del websocket
        try:
            self.close_requested = True
            if getattr(self, "ws", None):
                try:
                    self.ws.close()
                except Exception:
                    pass
                self.ws = None
        except Exception:
            pass

    # parar scheduler
        try:
            if hasattr(self, "scheduler") and self.scheduler and getattr(self.scheduler, "running", False):
                try:
                    self.scheduler.shutdown(wait=False)
                except Exception:
                    pass
        except Exception:
            pass

    # esperar thread ws
        try:
            if getattr(self, "ws_thread", None) and self.ws_thread.is_alive():
                self.ws_thread.join(timeout=2)
        except Exception:
            pass

    # destruir ventana en hilo principal (si no estamos en main thread, usar after)
        try:
            self.after(0, self.destroy)
        except Exception:
            try:
                self.destroy()
            except Exception:
                pass

    def request_window_redraw(self):
        try:
            if self.study_window and self.study_window.win.winfo_exists():
                self.after(0, lambda: self.update_chart_for_window(self.study_window))
        except Exception:
            pass
  
    # -----------------------
    # SIGNAL CHECK & ORDER LOGIC
    # -----------------------
    def check_for_trading_signal(self, is_real_mode=False):
        """
        Versión robusta y segura de check_for_trading_signal.
        Ejecuta en thread separado (APScheduler) y usa self.after para todas las interacciones con Tk.
        """
    # guard reentrancy
        if getattr(self, "_signal_lock", False):
            # log en hilo principal
            try:
                self.after(0, lambda: self.log_event("check_for_trading_signal ya en ejecución, saltando."))
            except Exception:
                pass
            return
        self._signal_lock = True

        def _read_ui_params():
            """Lectura segura de widgets; devuelve (trade_pct_decimal, tp_gui, sl_gui)"""
            try:
                val = self.trade_percentage_entry.get()
                trade_percentage = Decimal(val) / Decimal('100') if val else Decimal('0')
            except Exception:
                trade_percentage = Decimal('0')

            try:
                tp_gui = float(self.tp_entry.get()) / 100.0 if self.tp_entry.get() else None
            except Exception:
                tp_gui = None

            try:
                sl_gui = float(self.sl_entry.get()) / 100.0 if self.sl_entry.get() else None
            except Exception:
                sl_gui = None

            return trade_percentage, tp_gui, sl_gui

        def _job():
            try:
                client = get_binance_client(testnet=not is_real_mode)
                if not client:
                    try:
                        self.after(0, lambda: self.log_event("❌ No se pudo conectar a Binance."))
                    except Exception:
                        pass
                    return

            # obtener histórico
                historic = get_historic_candles(client, self.current_symbol, '1m', limit=300)
                if historic is None:
                    self.after(0, lambda: self.log_event("⚠️ No se obtuvo histórico para señales."))
                    return
                df = historic if isinstance(historic, pd.DataFrame) else pd.DataFrame(historic)
                if len(df) < 30:
                    self.after(0, lambda: self.log_event("⚠️ Datos insuficientes para señales."))
                    return

            # normalizar
                for col in ['open', 'high', 'low', 'close', 'volume']:
                    if col in df.columns:
                        df[col] = pd.to_numeric(df[col], errors='coerce')

                if not isinstance(df.index, pd.DatetimeIndex):
                    if 'open_time' in df.columns:
                        df['open_time'] = pd.to_datetime(df['open_time'], errors='coerce')
                        df = df.set_index('open_time')
                    elif 'time' in df.columns:
                        df['time'] = pd.to_datetime(df['time'], errors='coerce')
                        df = df.set_index('time')
                    elif 'timestamp' in df.columns:
                        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms', errors='coerce')
                        df = df.set_index('timestamp')

            # detect patterns (si existe detect_patterns)
                pattern_signals = None
                try:
                    res = detect_patterns(df)
                    if isinstance(res, tuple) and len(res) == 2:
                        detections, pattern_signals = res
                        self.pattern_detections = detections
                    else:
                    # si detect_patterns sólo devuelve series
                        if isinstance(res, pd.Series):
                            pattern_signals = res
                            self.pattern_detections = {}
                except NameError:
                    pattern_signals = None
                except Exception as e:
                    self.after(0, lambda e=e: self.log_event(f"Error detectando patrones: {e}"))
                    pattern_signals = None

            # último precio
                try:
                    last_price = Decimal(str(df['close'].iloc[-1]))
                except Exception:
                    self.after(0, lambda: self.log_event("Error leyendo último precio"))
                    return

            # sentimiento (función tuya)
                try:
                    sentiment = self.check_for_news_sentiment()
                except Exception:
                    sentiment = "neutral"

            # señal estrategia
                strat_sig = 0
                try:
                    signals = self.live_strategy(df, params=getattr(self, "live_strategy_params", {}))
                    if signals is not None:
                        if isinstance(signals, pd.DataFrame):
                            s = signals['signal'] if 'signal' in signals.columns else signals.iloc[:, 0]
                        else:
                            s = signals
                        if hasattr(s, "reindex"):
                            val = s.reindex(df.index).ffill().iloc[-1]
                        else:
                            val = s[-1]
                        v1 = str(val).upper()
                        strat_sig = 1 if v1 in ('BUY', '1', 'TRUE') else (-1 if v1 in ('SELL', '-1') else 0)
                except Exception as e:
                    self.after(0, lambda e=e: self.log_event(f"Error ejecutando estrategia: {e}"))
                    strat_sig = 0

            # pattern en última vela
                psig = 0
                try:
                    if isinstance(pattern_signals, (pd.Series, list, np.ndarray)) and len(pattern_signals) > 0:
                        last_idx = df.index[-1]
                        psig = int(pd.Series(pattern_signals, index=df.index).reindex([last_idx]).fillna(0).iloc[0])
                except Exception:
                    psig = 0

                final_signal = strat_sig if strat_sig != 0 else psig
                if final_signal == 0:
                    self.after(0, lambda: self.log_event("No hay señal combinada (estrategia+patrón)."))
                    return

            # leer parámetros GUI en hilo principal con after -> usar Event para comunicación
                ui_event = threading.Event()
                ui_res = {}

                def _read_ui():
                    ui_res['trade_pct'], ui_res['tp_gui'], ui_res['sl_gui'] = _read_ui_params()
                    ui_event.set()

                try:
                    self.after(0, _read_ui)
                # esperar hasta 1 segundo para lectura segura
                    ui_event.wait(timeout=1.0)
                except Exception:
                    pass

                trade_percentage = ui_res.get('trade_pct', Decimal('0'))
                tp_gui = ui_res.get('tp_gui', None)
                sl_gui = ui_res.get('sl_gui', None)

                if trade_percentage <= 0:
                    self.after(0, lambda: self.log_event("❌ Porcentaje de trade inválido (<=0)."))
                    return

            # saldo
                try:
                    all_balances = get_all_balances(client)
                    saldo_usdc = Decimal(all_balances.get('USDC', '0'))
                except Exception:
                    try:
                        saldo_usdc = Decimal(get_account_balance('USDC'))
                    except Exception:
                        saldo_usdc = Decimal('0')

                if saldo_usdc <= 0:
                    self.after(0, lambda: self.log_event("Saldo insuficiente para operar."))
                    return

                capital = (saldo_usdc * trade_percentage)
                if last_price <= 0:
                    self.after(0, lambda: self.log_event("Precio inválido para calcular qty."))
                    return

                try:
                    qty = (capital / last_price).quantize(Decimal("0.00000001"))
                except Exception:
                    self.after(0, lambda: self.log_event("Error calculando qty."))
                    return

            # Ejecutar orden (BUY)
                if final_signal == 1 and sentiment in ("positive", "neutral"):
                    self.after(0, lambda: self.log_event("Señal BUY confirmada. Ejecutando orden..."))
                    try:
                        self.after(0, lambda: self.log_event(f"[ORDEN] Intentando place_market_order -> symbol={self.current_symbol} side=BUY qty={qty}"))
                        try:
                            order_info = place_market_order(client, self.current_symbol, 'BUY', qty)
                            self.after(0, lambda order_info=order_info: self.log_event(f"[ORDEN] place_market_order response (BUY): {order_info}"))
                        except Exception as e:
                            order_info = None
                            self.after(0, lambda e=e: self.log_event(f"[ORDEN] Error ejecutando BUY: {e}"))
                    except Exception as e:
                        order_info = None
                        self.after(0, lambda e=e: self.log_event(f"Error ejecutando BUY: {e}"))

                    if order_info:
                        try:
                            executed_qty = Decimal(order_info.get('executedQty', '0'))
                            cum_quote = Decimal(order_info.get('cummulativeQuoteQty', '0'))
                            avg_price = (cum_quote / executed_qty) if executed_qty > 0 else last_price
                        except Exception:
                            avg_price = last_price

                        try:
                            self.telegram_api.send_message(
                                f"✅ ORDEN COMPRA EJECUTADA\nSímbolo: {order_info.get('symbol')}\nCantidad: {order_info.get('origQty')}\nPrecio Promedio: {float(avg_price):.8f}\nID Orden: {order_info.get('orderId')}"
                            )
                        except Exception:
                            pass

                        # calcular tp/sl (tu función)
                        try:
                            tp_price, sl_price = calculate_tp_sl(Decimal(avg_price if avg_price>0 else last_price),
                                                                # si calculate_tp_sl no acepta 'mode', omite ese argumento
                                                                mode=getattr(self, "current_strategy", "").lower(),
                                                                custom_tp=tp_gui, custom_sl=sl_gui)
                        except TypeError:
                            # fallback si calculate_tp_sl no acepta mode
                            tp_price, sl_price = calculate_tp_sl(Decimal(avg_price if avg_price>0 else last_price),
                                                                custom_tp=tp_gui, custom_sl=sl_gui)
                        except Exception as e:
                            self.after(0, lambda e=e: self.log_event(f"Error calculando TP/SL: {e}"))
                            tp_price, sl_price = None, None

                        if tp_price and sl_price:
                            try:
                                oco = place_oco_order(client, self.current_symbol, 'SELL', qty, tp_price, sl_price, sl_price)
                                if oco:
                                    try:
                                        self.telegram_api.send_message(f"🔐 OCO colocado. TP: {tp_price:.6f} SL: {sl_price:.6f}")
                                    except Exception:
                                        pass
                                else:
                                    self.after(0, lambda: self.log_event("Falló la colocación de OCO."))
                            except Exception as e:
                                self.after(0, lambda e=e: self.log_event(f"Error creando OCO: {e}"))
                # SELL
                elif final_signal == -1 and sentiment in ("negative", "neutral"):
                    self.after(0, lambda: self.log_event("Señal SELL confirmada. Ejecutando orden..."))
                    try:
                        self.after(0, lambda: self.log_event(f"[ORDEN] Intentando place_market_order -> symbol={self.current_symbol} side=SELL qty={qty}"))
                        try:
                            order_info = place_market_order(client, self.current_symbol, 'SELL', qty)
                            self.after(0, lambda order_info=order_info: self.log_event(f"[ORDEN] place_market_order response (SELL): {order_info}"))
                        except Exception as e:
                            order_info = None
                            self.after(0, lambda e=e: self.log_event(f"[ORDEN] Error ejecutando SELL: {e}"))
                    except Exception as e:
                        order_info = None
                        self.after(0, lambda e=e: self.log_event(f"Error ejecutando SELL: {e}"))

                    if order_info:
                        try:
                            executed_qty = Decimal(order_info.get('executedQty', '0'))
                            cum_quote = Decimal(order_info.get('cummulativeQuoteQty', '0'))
                            avg_price = (cum_quote / executed_qty) if executed_qty > 0 else last_price
                        except Exception:
                            avg_price = last_price

                        try:
                            self.telegram_api.send_message(
                                f"✅ ORDEN VENTA EJECUTADA\nSímbolo: {order_info.get('symbol')}\nCantidad: {order_info.get('origQty')}\nPrecio Promedio: {float(avg_price):.8f}\nID Orden: {order_info.get('orderId')}"
                            )
                        except Exception:
                            pass

                        try:
                            tp_price, sl_price = calculate_tp_sl(Decimal(avg_price if avg_price>0 else last_price),
                                                                mode=getattr(self, "current_strategy", "").lower(),
                                                                custom_tp=tp_gui, custom_sl=sl_gui)
                        except TypeError:
                            tp_price, sl_price = calculate_tp_sl(Decimal(avg_price if avg_price>0 else last_price),
                                                                custom_tp=tp_gui, custom_sl=sl_gui)
                        except Exception as e:
                            self.after(0, lambda e=e: self.log_event(f"Error calculando TP/SL: {e}"))
                            tp_price, sl_price = None, None

                        if tp_price and sl_price:
                            try:
                                oco = place_oco_order(client, self.current_symbol, 'BUY', qty, tp_price, sl_price, sl_price)
                                if oco:
                                    try:
                                        self.telegram_api.send_message(f"🔐 OCO colocado. TP: {tp_price:.6f} SL: {sl_price:.6f}")
                                    except Exception:
                                        pass
                                else:
                                    self.after(0, lambda: self.log_event("Falló la colocación de OCO."))
                            except Exception as e:
                                self.after(0, lambda e=e: self.log_event(f"Error creando OCO: {e}"))
                else:
                    self.after(0, lambda: self.log_event("Señal rechazada por sentimiento o condiciones."))

            except Exception as e:
            # capturar TODO para evitar que el scheduler cuelgue
                try:
                    self.after(0, lambda e=e: self.log_event(f"❌ Error en check_for_trading_signal: {e}"))
                except Exception:
                    pass
            finally:
                self._signal_lock = False

        Thread(target=_job, daemon=True).start()
    # -----------------------
    # CHARTS: functions to draw chart into StudyWindow
    # -----------------------
    def update_charts_initial(self):
        """Llamada inicial para forzar un primer redraw en la ventana de estudio (si existe)."""
        try:
            if self.study_window:
                self.update_chart_for_window(self.study_window)
        except Exception:
            pass

    def update_chart_for_window(self, window: StudyWindow):
        if not window.win.winfo_exists():
            return
        try:
        # === Cachear valores de los checkboxes para evitar acceso directo a BooleanVar ===
            show_ema = self.show_ema.get() if hasattr(self, "show_ema") else False
            show_macd = self.show_macd.get() if hasattr(self, "show_macd") else False
            show_rsi = self.show_rsi.get() if hasattr(self, "show_rsi") else False

            if self.df is None or self.df.empty:
                self.log_event("⚠️ DataFrame vacío, no se puede graficar.")
                try:    
                    window.fig.clf()
                    window.canvas.draw()
                except Exception:
                    pass
                return

            df_plot = self.df.copy()
            for col in ['open', 'high', 'low', 'close', 'volume']:
                if col in df_plot.columns:
                    df_plot[col] = pd.to_numeric(df_plot[col], errors='coerce')

            if not isinstance(df_plot.index, pd.DatetimeIndex):
                if 'time' in df_plot.columns:
                    df_plot = df_plot.set_index('time')
                elif 'timestamp' in df_plot.columns:
                    df_plot['time'] = pd.to_datetime(df_plot['timestamp'], unit='ms')
                    df_plot = df_plot.set_index('time')

            df_plot = df_plot.iloc[-500:].copy()
            if df_plot.empty:
                return

        # === Indicadores técnicos ===
            df_plot['ema9'] = df_plot['close'].ewm(span=9, adjust=False).mean()
            df_plot['ema20'] = df_plot['close'].ewm(span=20, adjust=False).mean()
            df_plot['ema50'] = df_plot['close'].ewm(span=50, adjust=False).mean()

            ema12 = df_plot['close'].ewm(span=12, adjust=False).mean()
            ema26 = df_plot['close'].ewm(span=26, adjust=False).mean()
            df_plot['macd'] = ema12 - ema26
            df_plot['macd_signal'] = df_plot['macd'].ewm(span=9, adjust=False).mean()
            df_plot['macd_hist'] = df_plot['macd'] - df_plot['macd_signal']

            delta = df_plot['close'].diff()
            gain = delta.where(delta > 0, 0)
            loss = -delta.where(delta < 0, 0)
            avg_gain = gain.rolling(window=14).mean()
            avg_loss = loss.rolling(window=14).mean()
            rs = avg_gain / avg_loss
            df_plot['rsi'] = 100 - (100 / (1 + rs))

        # === Estilo gráfico ===
            mc = mpf.make_marketcolors(
                up='green', down='red',
                wick={'up': 'black', 'down': 'black'},
                edge={'up': 'black', 'down': 'black'},
                volume='in'
            )
            style = mpf.make_mpf_style(base_mpf_style='binance', marketcolors=mc)

        # === Panel principal con EMAs ===
            addplots = []
            if show_ema:
                addplots += [
                    mpf.make_addplot(df_plot['ema9'], panel=0, color='purple', width=1.2),
                    mpf.make_addplot(df_plot['ema20'], panel=0, color='orange', width=1.2),
                    mpf.make_addplot(df_plot['ema50'], panel=0, color='blue', width=1.2),
            ]

        # === Panel MACD con histograma ===
            if show_macd:
                addplots += [
                    mpf.make_addplot(df_plot['macd'], panel=1, color='black', width=1),
                    mpf.make_addplot(df_plot['macd_signal'], panel=1, color='red', width=1),
                    mpf.make_addplot(df_plot['macd_hist'], panel=1, type='bar', color='dimgray', alpha=0.5),
            ]

        # === Panel RSI ===
            if show_rsi:
                addplots += [
                    mpf.make_addplot(df_plot['rsi'], panel=2, color='green', width=1),
                ]

        # === Marcadores de operaciones ===
            if hasattr(self, "trade_signals"):
                buys = self.trade_signals.get("buy", [])
                sells = self.trade_signals.get("sell", [])

                if buys:
                    buy_idx = [i for i in df_plot.index if i in buys]
                    buy_prices = df_plot.loc[buy_idx, "low"] * 0.995
                    addplots.append(
                        mpf.make_addplot(buy_prices, type="scatter", marker="^",
                                         markersize=100, color="green")
                    )

                if sells:
                    sell_idx = [i for i in df_plot.index if i in sells]
                    sell_prices = df_plot.loc[sell_idx, "high"] * 1.005
                    addplots.append(
                        mpf.make_addplot(sell_prices, type="scatter", marker="v",
                                         markersize=100, color="red")
                    )

        # === Tamaño dinámico ===
            try:
                w = max(6, window.win.winfo_width() / 100)
                h = max(4, window.win.winfo_height() / 100)
            except Exception:
                w, h = 12, 7

            if getattr(self, 'current_mpl_fig', None) is not None:
                plt.close(self.current_mpl_fig)

            fig_mpf, axes = mpf.plot(
                df_plot,
                type='candle',
                style=style,
                addplot=addplots,
                volume=True,
                datetime_format='%H:%M',
                returnfig=True,
                figsize=(w, h),
                tight_layout=True
            )

            self.current_mpl_fig = fig_mpf

        # === Renderizado en ventana ===
            try:
                window.canvas.figure = fig_mpf
                window.canvas.draw()
            except Exception:
                try:
                    window.canvas.get_tk_widget().destroy()
                except Exception:
                    pass
                window.canvas = FigureCanvasTkAgg(fig_mpf, master=window.win)
                window.canvas.get_tk_widget().pack(fill="both", expand=True)
                try:
                    window.toolbar.destroy()
                except Exception:
                    pass
                window.toolbar = NavigationToolbar2Tk(window.canvas, window.win)
                window.toolbar.update()
                window.canvas.draw()

        except Exception as e:
            self.log_event(f"Error actualizando StudyWindow charts: {e}")
    
...............................................................................................................

def run_websocket_thread(self, is_real_mode: bool):
    import json
    from threading import Thread
    import pandas as pd
    from datetime import datetime
    ws_url = "wss://stream.binance.com:9443/ws"
    symbol_stream = f"{self.current_symbol.lower()}@kline_1m"
    subscribe_message = {"method": "SUBSCRIBE", "params": [symbol_stream], "id": 1}



### Description

I have that code for a cryptocurrency trading bot that I'm creating... the thing is that I have unexpected closures and the graph is not how I would really like it, the volume overlaps with the MACD and it is not as interactive as I would like it to be, at least the minimum, with ZOOM and being able to drag the graph to see past candles... that is the huge chunk of code of more than 2500 lines that I have made and I do not know what parts are the ones that throw the program, I suppose something from the websocket or the graph itself, I do not know... and what I had of automatic trading does not work anymore when it detected sell and buy signals... I leave you the part of the code where I think there is the conflict to throw the program when it is studying... which will be the analysis or the websocket, and I have left the trading part, to see why it no longer makes operations and the part of the graph if it can be improved, because the volume overlaps with the MACD and I do not like how the MACD draws...
### NiceGUI Version

ninguna

### Python Version

3.11.9

### Browser

Chrome

### Operating System

Windows

### Additional Context

_No response_

[falkoschindler]

Hi @eagledj-design,

Please provide a minimum reproducible code example and explain your question or problem in English language (feel free to use a translation tool). Given 2500 lines of code it's very very hard to help you.