Skip to content
The Chat Archive
gpt-4o-2024-05-13· OpenAI WildChat-4.8M (AI2)

preciso que pllote na tela perto da mensagem de smart money concept o par te moeda que…

  1. User

    preciso que pllote na tela perto da mensagem de smart money concept o par te moeda que foi escolhida para ser analizada:

    import MetaTrader5 as mt5 import pandas as pd import matplotlib.pyplot as plt from datetime import datetime import time import threading import matplotlib.dates as mdates import requests import hashlib import wmi from matplotlib.animation import FuncAnimation import winsound

    URL do arquivo de HWIDs autorizados

    hwids_url = "https://raw.githubusercontent.com/wendelcassiano/Projetos-Design/main/hwid.txt"

    Função para obter HWID

    def get_hwid(): c = wmi.WMI() serial_number = None for disk in c.Win32_DiskDrive(): serial_number = disk.SerialNumber.strip() break if serial_number is None: raise ValueError("Não foi possível Gerar o HWID.") uuid_hash = hashlib.md5(serial_number.encode('utf-8')).hexdigest() formatted_uuid = f"{uuid_hash[:8]}-{uuid_hash[8:12]}-{uuid_hash[12:16]}-{uuid_hash[16:20]}-{uuid_hash[20:]}" return formatted_uuid

    Função para verificar HWID localmente

    def check_hwid_local(hwid): hwids_autorizados = [ "", # Adicione os HWIDs autorizados aqui ] return hwid in hwids_autorizados

    Função para verificar HWID online

    def check_hwid_online(hwids_url, hwid): try: response = requests.get(hwids_url) if response.status_code == 200: hwids = response.text.strip().split('\n') if hwid in hwids: return True else: return False else: print(f"Erro ao acessar Link: {response.status_code}") return False except requests.exceptions.RequestException as e: print(f"Erro de requisição: {e}") return False

    hwid = get_hwid() if not check_hwid_local(hwid): if not check_hwid_online(hwids_url, hwid): print(f"HWID do cliente: {hwid}") input("HWID não autorizado. Envie o Numero HWID para o vendedor…") quit()

    Conectando ao MetaTrader 5

    if not mt5.initialize(): print("initialize() failed, error code =", mt5.last_error()) quit()

    Função para selecionar o par de moedas

    def select_symbol(): symbols = ["EURUSD", "GBPUSD", "USDJPY", "USDCHF", "AUDUSD", "USDCAD", "NZDUSD"] print("Escolha o par de moedas:") for i, symbol in enumerate(symbols, 1): print(f"{i} {symbol}") choice = int(input("Digite o número correspondente ao par de moedas: ")) return symbols[choice - 1]

    Função para selecionar o timeframe

    def select_timeframe(): timeframes = { 1: ("15 Minutos", mt5.TIMEFRAME_M15), 2: ("30 Minutos", mt5.TIMEFRAME_M30), 3: ("1 Hora", mt5.TIMEFRAME_H1), 4: ("4 Horas", mt5.TIMEFRAME_H4), 5: ("1 Dia", mt5.TIMEFRAME_D1), 6: ("1 Semana", mt5.TIMEFRAME_W1), 7: ("1 Mês", mt5.TIMEFRAME_MN1) } print("Escolha o timeframe:") for key, (name, _) in timeframes.items(): print(f"{key} {name}") choice = int(input("Digite o número correspondente ao timeframe: ")) return timeframes[choice][1]

    Selecionar o ativo e timeframe

    symbol = select_symbol() timeframe = select_timeframe() mt5.symbol_select(symbol, True)

    Função para pegar dados históricos

    def get_data(symbol, timeframe, num_bars): rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, num_bars) data = pd.DataFrame(rates) data['time'] = pd.to_datetime(data['time'], unit='s') data.set_index('time', inplace=True) return data

    Função para atualizar os dados

    def update_data(): global data new_rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, 1000) new_data = pd.DataFrame(new_rates) new_data['time'] = pd.to_datetime(new_data['time'], unit='s') new_data.set_index('time', inplace=True) data = new_data

    Inicializar dados

    data = get_data(symbol, timeframe, 1000)

    Funções para análise técnica (mesmo código que você já tem)

    Função para encontrar Order Blocks

    def find_order_blocks(data, window=20): highs = data['high'].rolling(window=window).max() lows = data['low'].rolling(window=window).min() order_blocks = pd.DataFrame(index=data.index) order_blocks['bullish_ob'] = (data['close'] > highs.shift(1)) & (data['open'] < highs.shift(1)) order_blocks['bearish_ob'] = (data['close'] < lows.shift(1)) & (data['open'] > lows.shift(1)) return order_blocks

    Função para calcular Fair Value Gaps (FVG)

    def calculate_fvg(data): data['fvg'] = 0 for i in range(1, len(data)-1): if data['high'][i] < data['low'][i-1]: data['fvg'][i] = data['low'][i-1] - data['high'][i] elif data['low'][i] > data['high'][i-1]: data['fvg'][i] = data['low'][i] - data['high'][i-1] return data

    Função para detectar BOS e ChoCH

    def detect_bos_choch(data): data['bos'] = 0 data['choch'] = 0 for i in range(1, len(data)): if data['high'][i] > data['high'][i-1] and data['low'][i] > data['low'][i-1]: data['bos'][i] = 1 elif data['high'][i] < data['high'][i-1] and data['low'][i] < data['low'][i-1]: data['bos'][i] = -1 if data['bos'][i] == 1 and data['bos'][i-1] == -1: data['choch'][i] = 1 elif data['bos'][i] == -1 and data['bos'][i-1] == 1: data['choch'][i] = -1 return data

    Função para identificar a estrutura do mercado (altos e baixos mais altos/baixos)

    def identify_market_structure(data): data['higher_high'] = (data['high'] > data['high'].shift(1)) & (data['high'].shift(1) > data['high'].shift(2)) data['higher_low'] = (data['low'] > data['low'].shift(1)) & (data['low'].shift(1) > data['low'].shift(2)) data['lower_high'] = (data['high'] < data['high'].shift(1)) & (data['high'].shift(1) < data['high'].shift(2)) data['lower_low'] = (data['low'] < data['low'].shift(1)) & (data['low'].shift(1) < data['low'].shift(2)) return data

    Função para identificar zonas de liquidez

    def identify_liquidity_zones(data): data['liquidity_zone'] = 0 for i in range(1, len(data)): if data['high'][i] > data['high'][i-1]: data['liquidity_zone'][i] = 1 elif data['low'][i] < data['low'][i-1]: data['liquidity_zone'][i] = -1 return data

    Função para detectar padrões de engolfamento

    def detect_engulfing_patterns(data): data['bullish_engulf'] = (data['close'] > data['open']) & (data['close'].shift(1) < data['open'].shift(1)) & (data['open'] < data['close'].shift(1)) data['bearish_engulf'] = (data['close'] < data['open']) & (data['close'].shift(1) > data['open'].shift(1)) & (data['open'] > data['close'].shift(1)) return data

    Função para aplicar indicadores técnicos

    def apply_technical_indicators(data): data['ema_50'] = data['close'].ewm(span=50, adjust=False).mean() data['ema_200'] = data['close'].ewm(span=200, adjust=False).mean() data['rsi'] = calculate_rsi(data['close']) return data

    def calculate_rsi(series, period=14): delta = series.diff() gain = (delta.where(delta > 0, 0)).rolling(window=period).mean() loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean() rs = gain / loss return 100 - (100 / (1 + rs))

    Função para calcular a volatilidade

    def calculate_volatility(data, window=20): data['volatility'] = data['close'].rolling(window=window).std() return data

    Lógica para detectar sinais de compra ou venda

    def detect_signals(data): order_blocks = find_order_blocks(data) data = calculate_fvg(data) data = detect_bos_choch(data) data = identify_market_structure(data) data = identify_liquidity_zones(data) data = detect_engulfing_patterns(data) data = apply_technical_indicators(data)

    signals = pd.DataFrame(index=data.index)
    signals['signal'] = 0
    signals['tp'] = 0.0
    signals['sl'] = 0.0
    signals['open_price'] = 0.0
    signals['liquidity_message'] = ""
    
    for i in range(len(data)):
        if order_blocks['bullish_ob'][i] and data['choch'][i] == 1:
            signals.loc[data.index[i], 'signal'] = 1
            signals.loc[data.index[i], 'tp'] = data['close'][i] + 0.005
            signals.loc[data.index[i], 'sl'] = data['close'][i] - 0.002
            signals.loc[data.index[i], 'open_price'] = data['open'][i+1]
        elif order_blocks['bearish_ob'][i] and data['choch'][i] == -1:
            signals.loc[data.index[i], 'signal'] = -1
            signals.loc[data.index[i], 'tp'] = data['close'][i] - 0.005
            signals.loc[data.index[i], 'sl'] = data['close'][i] + 0.002
            signals.loc[data.index[i], 'open_price'] = data['open'][i+1]
    # Adicionar mensagem de liquidez apenas no último sinal
    last_signal_index = signals[signals['signal'] != 0].index[-1]
    liquidity_zone = data.loc[last_signal_index, 'liquidity_zone']
    if liquidity_zone == 1:
        signals.loc[last_signal_index, 'liquidity_message'] = "------ Liquidez Acima"
    elif liquidity_zone == -1:
        signals.loc[last_signal_index, 'liquidity_message'] = "------ Liquidez Abaixo"
    
    return signals
    

    Variável global para armazenar o índice do último sinal verificado

    last_signal_index = None

    Função para plotar gráfico de candlestick com sinais e volatilidade

    def plot_chart_with_signals(i): global data, last_signal_index update_data()

    signals = detect_signals(data)
    data = calculate_volatility(data)
    volatility_state = get_volatility_state(data)
    
    ax1.clear()
    ax2.clear()
    
    ax1.set_title(volatility_state)
    
    time_delta = data.index[1] - data.index[0]
    width = time_delta.total_seconds() / (24 * 60 * 60) * 0.8
    
    ax1.bar(data.index, data["close"] - data["open"], width=width, bottom=data["open"], color="black", align="center", label="Candlestick")
    ax1.vlines(data.index, data["low"], data["high"], color="black", linewidth=1)
    
    new_signals_detected = False  # Inicializa como False
    
    for i in range(len(signals)):
        if signals["signal"].iloc[i] == 1:
            ax1.scatter(signals.index[i], signals["open_price"].iloc[i], marker="^", color="green", label="Compra")
            ax1.text(signals.index[i], signals["open_price"].iloc[i], f"Open: {signals["open_price"].iloc[i]:.5f}\nTP: {signals["tp"].iloc[i]:.5f}\nSL: {signals["sl"].iloc[i]:.5f}", fontsize=10, ha="center", va="bottom", color="green")
            if last_signal_index is None or signals.index[i] > last_signal_index:
                new_signals_detected = True
        elif signals["signal"].iloc[i] == -1:
            ax1.scatter(signals.index[i], signals["open_price"].iloc[i], marker="v", color="red", label="Venda")
            ax1.text(signals.index[i], signals["open_price"].iloc[i], f"Open: {signals["open_price"].iloc[i]:.5f}\nTP: {signals["tp"].iloc[i]:.5f}\nSL: {signals["sl"].iloc[i]:.5f}", fontsize=10, ha="center", va="top", color="red")
            if last_signal_index is None or signals.index[i] > last_signal_index:
                new_signals_detected = True
    
        # Adicionar mensagem de liquidez apenas no último sinal
        if signals["liquidity_message"].iloc[i]:
            ax1.text(signals.index[i], data["high"].iloc[i], signals["liquidity_message"].iloc[i], color="blue", ha="left")
    
    # Atualizar o índice do último sinal verificado
    if not signals.empty:
        last_signal_index = signals.index[-1]
    
    # Emitir beeps se novos sinais foram detectados
    if new_signals_detected:
        for _ in range(3):
            winsound.Beep(1000, 500)
    
    ax1.set_xlabel("Data")
    ax1.set_ylabel("Preço")
    ax1.legend(loc="upper left")
    ax1.grid(True)
    ax1.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %H:%M:%S"))
    
    ax2.plot(data.index, data["volatility"], label="Volatilidade")
    ax2.set_xlabel("Data")
    ax2.set_ylabel("Volatilidade")
    ax2.legend(loc="upper left")
    ax2.grid(True)
    

    Função para determinar o estado do mercado com base na volatilidade

    def get_volatility_state(data, threshold_high=0.0005, threshold_low=0.0001): latest_volatility = data['volatility'].iloc[-1] if latest_volatility > threshold_high: return "Mercado Muito Volátil" elif latest_volatility < threshold_low: return "Mercado com Baixa Volatilidade" else: return "Mercado com Volatilidade Moderada"

    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8)) plt.suptitle('Gráfico Indicador Smart Money Concept')

    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000) plt.show()

    me de o trecho que precisa ser alterado

  2. Assistant

    Para adicionar o par de moeda que foi escolhido para ser analisado junto à mensagem de "Smart Money Concept", você precisa atualizar o título principal da figura (plt.suptitle) para incluir o par de moedas (symbol). Aqui está o trecho atualizado para isso:

    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
    plt.suptitle(f'Gráfico Indicador Smart Money Concept - {symbol}')
    
    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000)
    plt.show()
    

    Isso adiciona o símbolo da moeda ao título da figura. Segue o código completo atualizado com essa modificação:

    import MetaTrader5 as mt5
    import pandas as pd
    import matplotlib.pyplot as plt
    from datetime import datetime
    import time
    import threading
    import matplotlib.dates as mdates
    import requests
    import hashlib
    import wmi
    from matplotlib.animation import FuncAnimation
    import winsound
    
    # URL do arquivo de HWIDs autorizados
    hwids_url = "https://raw.githubusercontent.com/wendelcassiano/Projetos-Design/main/hwid.txt"
    
    # Função para obter HWID
    def get_hwid():
        c = wmi.WMI()
        serial_number = None
        for disk in c.Win32_DiskDrive():
            serial_number = disk.SerialNumber.strip()
            break
        if serial_number is None:
            raise ValueError("Não foi possível Gerar o HWID.")
        uuid_hash = hashlib.md5(serial_number.encode('utf-8')).hexdigest()
        formatted_uuid = f"{uuid_hash[:8]}-{uuid_hash[8:12]}-{uuid_hash[12:16]}-{uuid_hash[16:20]}-{uuid_hash[20:]}"
        return formatted_uuid
    
    # Função para verificar HWID localmente
    def check_hwid_local(hwid):
        hwids_autorizados = [
            "",  # Adicione os HWIDs autorizados aqui
        ]
        return hwid in hwids_autorizados
    
    # Função para verificar HWID online
    def check_hwid_online(hwids_url, hwid):
        try:
            response = requests.get(hwids_url)
            if response.status_code == 200:
                hwids = response.text.strip().split('\n')
                if hwid in hwids:
                    return True
                else:
                    return False
            else:
                print(f"Erro ao acessar Link: {response.status_code}")
                return False
        except requests.exceptions.RequestException as e:
            print(f"Erro de requisição: {e}")
            return False
    
    hwid = get_hwid()
    if not check_hwid_local(hwid):
        if not check_hwid_online(hwids_url, hwid):
            print(f"HWID do cliente: {hwid}")
            input("HWID não autorizado. Envie o Numero HWID para o vendedor…")
            quit()
    
    # Conectando ao MetaTrader 5
    if not mt5.initialize():
        print("initialize() failed, error code =", mt5.last_error())
        quit()
    
    # Função para selecionar o par de moedas
    def select_symbol():
        symbols = ["EURUSD", "GBPUSD", "USDJPY", "USDCHF", "AUDUSD", "USDCAD", "NZDUSD"]
        print("Escolha o par de moedas:")
        for i, symbol in enumerate(symbols, 1):
            print(f"{i} {symbol}")
        choice = int(input("Digite o número correspondente ao par de moedas: "))
        return symbols[choice - 1]
    
    # Função para selecionar o timeframe
    def select_timeframe():
        timeframes = {
            1: ("15 Minutos", mt5.TIMEFRAME_M15),
            2: ("30 Minutos", mt5.TIMEFRAME_M30),
            3: ("1 Hora", mt5.TIMEFRAME_H1),
            4: ("4 Horas", mt5.TIMEFRAME_H4),
            5: ("1 Dia", mt5.TIMEFRAME_D1),
            6: ("1 Semana", mt5.TIMEFRAME_W1),
            7: ("1 Mês", mt5.TIMEFRAME_MN1)
        }
        print("Escolha o timeframe:")
        for key, (name, _) in timeframes.items():
            print(f"{key} {name}")
        choice = int(input("Digite o número correspondente ao timeframe: "))
        return timeframes[choice][1]
    
    # Selecionar o ativo e timeframe
    symbol = select_symbol()
    timeframe = select_timeframe()
    mt5.symbol_select(symbol, True)
    
    # Função para pegar dados históricos
    def get_data(symbol, timeframe, num_bars):
        rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, num_bars)
        data = pd.DataFrame(rates)
        data['time'] = pd.to_datetime(data['time'], unit='s')
        data.set_index('time', inplace=True)
        return data
    
    # Função para atualizar os dados
    def update_data():
        global data
        new_rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, 1000)
        new_data = pd.DataFrame(new_rates)
        new_data['time'] = pd.to_datetime(new_data['time'], unit='s')
        new_data.set_index('time', inplace=True)
        data = new_data
    
    # Inicializar dados
    data = get_data(symbol, timeframe, 1000)
    
    # Funções para análise técnica (mesmo código que você já tem)
    # Função para encontrar Order Blocks
    def find_order_blocks(data, window=20):
        highs = data['high'].rolling(window=window).max()
        lows = data['low'].rolling(window=window).min()
        order_blocks = pd.DataFrame(index=data.index)
        order_blocks['bullish_ob'] = (data['close'] > highs.shift(1)) & (data['open'] < highs.shift(1))
        order_blocks['bearish_ob'] = (data['close'] < lows.shift(1)) & (data['open'] > lows.shift(1))
        return order_blocks
    
    
    # Função para calcular Fair Value Gaps (FVG)
    def calculate_fvg(data):
        data['fvg'] = 0
        for i in range(1, len(data)-1):
            if data['high'][i] < data['low'][i-1]:
                data['fvg'][i] = data['low'][i-1] - data['high'][i]
            elif data['low'][i] > data['high'][i-1]:
                data['fvg'][i] = data['low'][i] - data['high'][i-1]
        return data
    
    
    # Função para detectar BOS e ChoCH
    def detect_bos_choch(data):
        data['bos'] = 0
        data['choch'] = 0
        for i in range(1, len(data)):
            if data['high'][i] > data['high'][i-1] and data['low'][i] > data['low'][i-1]:
                data['bos'][i] = 1
            elif data['high'][i] < data['high'][i-1] and data['low'][i] < data['low'][i-1]:
                data['bos'][i] = -1
            if data['bos'][i] == 1 and data['bos'][i-1] == -1:
                data['choch'][i] = 1
            elif data['bos'][i] == -1 and data['bos'][i-1] == 1:
                data['choch'][i] = -1
        return data
    
    
    # Função para identificar a estrutura do mercado (altos e baixos mais altos/baixos)
    def identify_market_structure(data):
        data['higher_high'] = (data['high'] > data['high'].shift(1)) & (data['high'].shift(1) > data['high'].shift(2))
        data['higher_low'] = (data['low'] > data['low'].shift(1)) & (data['low'].shift(1) > data['low'].shift(2))
        data['lower_high'] = (data['high'] < data['high'].shift(1)) & (data['high'].shift(1) < data['high'].shift(2))
        data['lower_low'] = (data['low'] < data['low'].shift(1)) & (data['low'].shift(1) < data['low'].shift(2))
        return data
    
    
    # Função para identificar zonas de liquidez
    def identify_liquidity_zones(data):
        data['liquidity_zone'] = 0
        for i in range(1, len(data)):
            if data['high'][i] > data['high'][i-1]:
                data['liquidity_zone'][i] = 1
            elif data['low'][i] < data['low'][i-1]:
                data['liquidity_zone'][i] = -1
        return data
    
    
    # Função para detectar padrões de engolfamento
    def detect_engulfing_patterns(data):
        data['bullish_engulf'] = (data['close'] > data['open']) & (data['close'].shift(1) < data['open'].shift(1)) & (data['open'] < data['close'].shift(1))
        data['bearish_engulf'] = (data['close'] < data['open']) & (data['close'].shift(1) > data['open'].shift(1)) & (data['open'] > data['close'].shift(1))
        return data
    
    # Função para aplicar indicadores técnicos
    def apply_technical_indicators(data):
        data['ema_50'] = data['close'].ewm(span=50, adjust=False).mean()
        data['ema_200'] = data['close'].ewm(span=200, adjust=False).mean()
        data['rsi'] = calculate_rsi(data['close'])
        return data
    
    def calculate_rsi(series, period=14):
        delta = series.diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))
    
    
    # Função para calcular a volatilidade
    def calculate_volatility(data, window=20):
        data['volatility'] = data['close'].rolling(window=window).std()
        return data
    
    
    # Lógica para detectar sinais de compra ou venda
    def detect_signals(data):
        order_blocks = find_order_blocks(data)
        data = calculate_fvg(data)
        data = detect_bos_choch(data)
        data = identify_market_structure(data)
        data = identify_liquidity_zones(data)
        data = detect_engulfing_patterns(data)
        data = apply_technical_indicators(data)
        
        signals = pd.DataFrame(index=data.index)
        signals['signal'] = 0
        signals['tp'] = 0.0
        signals['sl'] = 0.0
        signals['open_price'] = 0.0
        signals['liquidity_message'] = ""
        
        for i in range(len(data)):
            if order_blocks['bullish_ob'][i] and data['choch'][i] == 1:
                signals.loc[data.index[i], 'signal'] = 1
                signals.loc[data.index[i], 'tp'] = data['close'][i] + 0.005
                signals.loc[data.index[i], 'sl'] = data['close'][i] - 0.002
                signals.loc[data.index[i], 'open_price'] = data['open'][i+1]
            elif order_blocks['bearish_ob'][i] and data['choch'][i] == -1:
                signals.loc[data.index[i], 'signal'] = -1
                signals.loc[data.index[i], 'tp'] = data['close'][i] - 0.005
                signals.loc[data.index[i], 'sl'] = data['close'][i] + 0.002
                signals.loc[data.index[i], 'open_price'] = data['open'][i+1]
        # Adicionar mensagem de liquidez apenas no último sinal
        last_signal_index = signals[signals['signal'] != 0].index[-1]
        liquidity_zone = data.loc[last_signal_index, 'liquidity_zone']
        if liquidity_zone == 1:
            signals.loc[last_signal_index, 'liquidity_message'] = "------ Liquidez Acima"
        elif liquidity_zone == -1:
            signals.loc[last_signal_index, 'liquidity_message'] = "------ Liquidez Abaixo"
        
        return signals
    
    
    # Variável global para armazenar o índice do último sinal verificado
    last_signal_index = None    
    
    # Função para plotar gráfico de candlestick com sinais e volatilidade
    def plot_chart_with_signals(i):
        global data, last_signal_index
        update_data()
        
        signals = detect_signals(data)
        data = calculate_volatility(data)
        volatility_state = get_volatility_state(data)
    
        ax1.clear()
        ax2.clear()
        
        ax1.set_title(volatility_state)
        
        time_delta = data.index[1] - data.index[0]
        width = time_delta.total_seconds() / (24 * 60 * 60) * 0.8
        
        ax1.bar(data.index, data["close"] - data["open"], width=width, bottom=data["open"], color="black", align="center", label="Candlestick")
        ax1.vlines(data.index, data["low"], data["high"], color="black", linewidth=1)
        
        new_signals_detected = False  # Inicializa como False
    
        for i in range(len(signals)):
            if signals["signal"].iloc[i] == 1:
                ax1.scatter(signals.index[i], signals["open_price"].iloc[i], marker="^", color="green", label="Compra")
                ax1.text(signals.index[i], signals["open_price"].iloc[i], f"Open: {signals["open_price"].iloc[i]:.5f}\nTP: {signals["tp"].iloc[i]:.5f}\nSL: {signals["sl"].iloc[i]:.5f}", fontsize=10, ha="center", va="bottom", color="green")
                if last_signal_index is None or signals.index[i] > last_signal_index:
                    new_signals_detected = True
            elif signals["signal"].iloc[i] == -1:
                ax1.scatter(signals.index[i], signals["open_price"].iloc[i], marker="v", color="red", label="Venda")
                ax1.text(signals.index[i], signals["open_price"].iloc[i], f"Open: {signals["open_price"].iloc[i]:.5f}\nTP: {signals["tp"].iloc[i]:.5f}\nSL: {signals["sl"].iloc[i]:.5f}", fontsize=10, ha="center", va="top", color="red")
                if last_signal_index is None or signals.index[i] > last_signal_index:
                    new_signals_detected = True
    
            # Adicionar mensagem de liquidez apenas no último sinal
            if signals["liquidity_message"].iloc[i]:
                ax1.text(signals.index[i], data["high"].iloc[i], signals["liquidity_message"].iloc[i], color="blue", ha="left")
    
        # Atualizar o índice do último sinal verificado
        if not signals.empty:
            last_signal_index = signals.index[-1]
        
        # Emitir beeps se novos sinais foram detectados
        if new_signals_detected:
            for _ in range(3):
                winsound.Beep(1000, 500)
    
        ax1.set_xlabel("Data")
        ax1.set_ylabel("Preço")
        ax1.legend(loc="upper left")
        ax1.grid(True)
        ax1.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %H:%M:%S"))
    
        ax2.plot(data.index, data["volatility"], label="Volatilidade")
        ax2.set_xlabel("Data")
        ax2.set_ylabel("Volatilidade")
        ax2.legend(loc="upper left")
        ax2.grid(True)
    
    
    
    # Função para determinar o estado do mercado com base na volatilidade
    def get_volatility_state(data, threshold_high=0.0005, threshold_low=0.0001):
        latest_volatility = data['volatility'].iloc[-1]
        if latest_volatility > threshold_high:
            return "Mercado Muito Volátil"
        elif latest_volatility < threshold_low:
            return "Mercado com Baixa Volatilidade"
        else:
            return "Mercado com Volatilidade Moderada"
    
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
    plt.suptitle(f'Gráfico Indicador Smart Money Concept - {symbol}')
    
    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000)
    plt.show()
    

    Com essa modificação, o título do gráfico incluirá o par de moedas escolhido, tornando mais fácil para o usuário identificar qual par está sendo analisado.