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

A value is trying to be set on a copy of a slice from a DataFrame See the caveats in the…

  1. User

    A value is trying to be set on a copy of a slice from a DataFrame

    See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy data['choch'][i] = -1 Smart_Money_Updated_04.py:94: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame

    See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy data['bos'][i] = -1 Smart_Money_Updated_04.py:94: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame

    See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy data['bos'][i] = -1 Smart_Money_Updated_04.py:94: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame

    See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy data['bos'][i] = -1 Traceback (most recent call last): File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\cbook_init_.py", line 314, in process func(*args, **kwargs) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\animation.py", line 904, in _start self._init_draw() File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\animation.py", line 1748, in _init_draw self._draw_frame(frame_data) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\animation.py", line 1767, in _draw_frame self._drawn_artists = self._func(framedata, *self._args) File "Smart_Money_Updated_04.py", line 325, in plot_chart_with_signals swing_high, swing_low = detect_swing_points(data) File "Smart_Money_Updated_04.py", line 247, in detect_swing_points swing_low = data['low'].iloc[int(swing_low_idx)] TypeError: int() argument must be a string, a bytes-like object or a number, not 'Timestamp'

    meu codigo abaixo:

    import MetaTrader5 as mt5 import pandas as pd import matplotlib.pyplot as plt from datetime import datetime import matplotlib.dates as mdates from matplotlib.animation import FuncAnimation import winsound import numpy as np

    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", "GOLD", "BTCUSD", "US500Cash", "US30Cash"] 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))

    data['trend'] = 'Neutro'
    data.loc[data['higher_high'] & data['higher_low'], 'trend'] = 'Alta'
    data.loc[data['lower_high'] & data['lower_low'], 'trend'] = 'Baixa'
    
    return data
    

    Função para identificar zonas de liquidez

    def identify_liquidity_zones(data): data['liquidity_zone'] = 0 data.loc[data['high'] > data['high'].shift(1), 'liquidity_zone'] = 1 data.loc[data['low'] < data['low'].shift(1), 'liquidity_zone'] = -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

    Função para determinar a tendência

    def determine_trend(data): data['trend'] = "Indefinida" data.loc[data['ema_50'] > data['ema_200'], 'trend'] = "Alta" data.loc[data['ema_50'] < data['ema_200'], 'trend'] = "Baixa" return data

    Função para calcular o ADX sem usar talib

    def calculate_adx(data, period=14): data['high_diff'] = data['high'].diff() data['low_diff'] = data['low'].diff()

    data['plus_dm'] = np.where((data['high_diff'] > 0) & (data['high_diff'] > data['low_diff']), data['high_diff'], 0)
    data['minus_dm'] = np.where((data['low_diff'] > 0) & (data['low_diff'] > data['high_diff']), data['low_diff'], 0)
    
    data['atr'] = data['high'].diff().abs().rolling(window=period).mean()
    
    data['plus_di'] = 100 * (data['plus_dm'].rolling(window=period).sum() / data['atr'])
    data['minus_di'] = 100 * (data['minus_dm'].rolling(window=period).sum() / data['atr'])
    
    data['adx'] = 100 * ((data['plus_di'] - data['minus_di']).abs() / (data['plus_di'] + data['minus_di']).abs()).rolling(window=period).mean()
    
    conditions = [
        (data['adx'] > 50),
        (data['adx'] > 25),
        (data['adx'] > 20),
        (data['adx'] > 15),
        (data['adx'] <= 15)
    ]
    
    choices = ['Muito Forte', 'Forte', 'Moderada', 'Fraca', 'Muito Fraca']
    data['trend_strength_label'] = np.select(conditions, choices, default='Neutra')
    
    return data.drop(['high_diff', 'low_diff', 'plus_dm', 'minus_dm', 'atr', 'plus_di', 'minus_di', 'adx'], axis=1) 
    

    Atualizar a função calculate_trend_strength para usar o calculate_adx

    def calculate_trend_strength(data): data = calculate_adx(data) 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 = []
    for i in range(len(data)):
        if order_blocks['bullish_ob'][i] and data['choch'][i] == 1:
            signals.append({'index': data.index[i], 'signal': 1, 'tp': data['close'][i] + 0.005, 'sl': data['close'][i] - 0.002, 'open_price': data['open'][i + 1]})
        elif order_blocks['bearish_ob'][i] and data['choch'][i] == -1:
            signals.append({'index': data.index[i], 'signal': -1, 'tp': data['close'][i] - 0.005, 'sl': data['close'][i] + 0.002, 'open_price': data['open'][i + 1]})
    
    # Filtrar sinais ativos
    signals = [s for s in signals if (s['signal'] == 1 and (data['high'].loc[s['index']:] < s['tp']).all()) or (s['signal'] == -1 and (data['low'].loc[s['index']:] > s['sl']).all())]
    
    # Adicionar mensagens de liquidez apenas no último sinal
    if signals:
        last_signal = signals[-1]
        liquidity_zone = data.loc[last_signal['index'], 'liquidity_zone']
        if liquidity_zone == 1:
            last_signal['liquidity_message'] = "------ Liquidez Acima"
        elif liquidity_zone == -1:
            last_signal['liquidity_message'] = "------ Liquidez Abaixo"
    
    return signals
    

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

    last_signal_index = None

    Função para calcular os níveis de Fibonacci

    def calculate_fibo_levels(swing_high, swing_low): fibo_levels = { 'Equilíbrio (50%)': (swing_high + swing_low) / 2, '0.618': swing_low + (swing_high - swing_low) * 0.618, '0.709 (OTE)': swing_low + (swing_high - swing_low) * 0.709, '0.786': swing_low + (swing_high - swing_low) * 0.786, '0.886': swing_low + (swing_high - swing_low) * 0.886, '1.13 (SL)': swing_low + (swing_high - swing_low) * 1.13, '-0.27 (TP1)': swing_high + (swing_high - swing_low) * 0.27, '-0.62 (TP2)': swing_high + (swing_high - swing_low) * 0.62, '-1.00 (TP3)': swing_high + (swing_high - swing_low) * 1.00, '-1.61 (Swing Trade)': swing_high + (swing_high - swing_low) * 1.61 } return fibo_levels

    Função para detectar os pontos de swing high e swing low mais recentes

    def detect_swing_points(data, window=20): # Criação de arrays temporários para armazenar índices máximos e mínimos highest_idx = data['high'].rolling(window=window).apply(lambda x: np.argmax(x), raw=True) lowest_idx = data['low'].rolling(window=window).apply(lambda x: np.argmin(x), raw=True).index

    # Pegando os timestamps que correspondem aos índices armazenados
    swing_high_idx = highest_idx.iloc[-1]
    swing_low_idx = lowest_idx[-1]
    
    swing_high = data['high'].iloc[int(swing_high_idx)]
    swing_low = data['low'].iloc[int(swing_low_idx)]
    
    return swing_high, swing_low
    

    Variáveis globais

    data = None # Você deve inicializar isso de forma apropriada em algum ponto do seu código last_signal_index = None data_multiple = None # Inicialize apropriadamente mais tarde multiple_assets_analysis = None active_fibo = None active_signal = None # Inicializa a variável como None

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

    def plot_chart_with_signals(i): global data, last_signal_index, data_multiple, multiple_assets_analysis, active_fibo, active_signal update_data()

    signals = detect_signals(data)
    data = calculate_volatility(data)
    data = determine_trend(data)
    data = calculate_trend_strength(data)
    volatility_state = get_volatility_state(data)
    
    fig.suptitle(f'Gráfico Indicador Smart Money Concept - {symbol}', fontsize=10, fontweight='bold')
    
    ax1.clear()
    ax2.clear()
    
    # Remover o título atual
    # ax1.set_title(volatility_state, fontsize=12)  # Isso não é mais necessário
    
    # Adicionar o texto da volatilidade em uma posição específica
    fig.text(0.5, 0.92, volatility_state, ha='center', va='top', fontsize=10, fontweight='bold')  # Ajuste os valores de x, y, ha, e va conforme necessário
    
    trends_multiple = determine_trend_multiple_timeframes(data_multiple)
    trend_message = f"M15: {trends_multiple['M15']}, M30: {trends_multiple['M30']}, H1: {trends_multiple['H1']}, H4: {trends_multiple['H4']}, D1: {trends_multiple['D1']}"
    fig.text(0.2, 0.93, trend_message, color="green", ha="center", va="center", fontsize=6, fontweight='normal')
    
    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
    
    for signal in signals:
        if signal["signal"] == 1:
            ax1.scatter(signal['index'], signal['open_price'], marker="^", color="green", label="Compra")
            ax1.text(signal['index'], signal['open_price'], f"Open: {signal['open_price']:.5f}\nTP: {signal['tp']:.5f}\nSL: {signal['sl']:.5f}", fontsize=10, ha="center", va="bottom", color="green")
            if last_signal_index is None or signal['index'] > last_signal_index:
                new_signals_detected = True
        elif signal["signal"] == -1:
            ax1.scatter(signal['index'], signal['open_price'], marker="v", color="red", label="Venda")
            ax1.text(signal['index'], signal['open_price'], f"Open: {signal['open_price']:.5f}\nTP: {signal['tp']:.5f}\nSL: {signal['sl']:.5f}", fontsize=10, ha="center", va="top", color="red")
            if last_signal_index is None or signal['index'] > last_signal_index:
                new_signals_detected = True
    
        if "liquidity_message" in signal:
            ax1.text(signal['index'], data["high"].loc[signal['index']], signal["liquidity_message"], color="blue", ha="left")
    
    trend_message = f"Tendência: {data['trend'].iloc[-1]}, Força: {data['trend_strength_label'].iloc[-1]}"
    fig.text(0.5, 0.93, trend_message, color="blue", ha="center", va="center", fontsize=10, fontweight='normal')
    
    if signals:
        last_signal_index = signals[-1]['index']
    
    
    if new_signals_detected:
        for _ in range(3):
            winsound.Beep(1000, 500)
    
    # Se não há sinal ativo ou o sinal foi cancelado, detectar um novo sinal
    if active_signal is None:
        # Detectar pontos de swing high e swing low
        swing_high, swing_low = detect_swing_points(data)
        
        # Calcular níveis de Fibonacci
        active_fibo = calculate_fibo_levels(swing_high, swing_low)
        
        # Detecção de sinais
        signals = detect_signals(data)
    
        # Selecionar o último sinal gerado
        if signals:
            active_signal = signals[-1]
    
    # Se há um sinal ativo, plotar os níveis de Fibonacci e verificar se o TP ou SL foi atingido
    if active_signal:
        for level_name, level_value in active_fibo.items():
            ax1.axhline(level_value, color='blue', linestyle='–')
            ax1.text(data.index[-1], level_value, f'{level_name}: {level_value:.5f}', fontsize=8, ha='right', color='blue')
        
        # Plotar o sinal ativo
        if active_signal["signal"] == 1:
            ax1.scatter(active_signal['index'], active_signal['open_price'], marker="^", color="green", label="Compra")
            ax1.text(active_signal['index'], active_signal['open_price'], f'{active_signal["open_price"]:.5f}', fontsize=8, ha="center", va="bottom", color="green")
        elif active_signal["signal"] == -1:
            ax1.scatter(active_signal['index'], active_signal['open_price'], marker="v", color="red", label="Venda")
            ax1.text(active_signal['index'], active_signal['open_price'], f'{active_signal["open_price"]:.5f}', fontsize=8, ha="center", va="top", color="red")
    
        # Verificar se o TP ou SL do sinal ativo foi atingido
        high_prices = data.loc[active_signal['index']:, 'high']
        low_prices = data.loc[active_signal['index']:, 'low']
        if active_signal["signal"] == 1 and (high_prices >= active_fibo['-0.27 (TP1)']).any():
            active_signal = None
        elif active_signal["signal"] == 1 and (low_prices <= active_fibo['1.13 (SL)']).any():
            active_signal = None
        elif active_signal["signal"] == -1 and (low_prices <= active_fibo['-0.27 (TP1)']).any():
            active_signal = None
        elif active_signal["signal"] == -1 and (high_prices >= active_fibo['1.13 (SL)']).any():
            active_signal = None
    
    ax1.set_xlabel("Data")
    ax1.set_ylabel("Preço")
    ax1.legend(loc="upper left")
    ax1.grid(True)
    ax1.xaxis.set_major_formatter(mdates.DateFormatter("%d-%m-%Y\n%H:%M"))
    plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45, ha="right", rotation_mode="anchor", fontsize=6)
    
    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 pegar dados históricos para múltiplos timeframes

    def get_data_multiple_timeframes(symbol, timeframes, num_bars): data = {} for tf_name, tf in timeframes.items(): rates = mt5.copy_rates_from_pos(symbol, tf, 0, num_bars) df = pd.DataFrame(rates) df['time'] = pd.to_datetime(df['time'], unit='s') df.set_index('time', inplace=True) data[tf_name] = df return data

    Função para determinar a tendência em múltiplos timeframes

    def determine_trend_multiple_timeframes(data): trends = {} for tf, df in data.items(): df = apply_technical_indicators(df) # Aplicar indicadores técnicos df['trend'] = "Indefinida" df['ema_50'] = df['close'].ewm(span=50, adjust=False).mean() df['ema_200'] = df['close'].ewm(span=200, adjust=False).mean() df.loc[df['ema_50'] > df['ema_200'], 'trend'] = "Alta" df.loc[df['ema_50'] < df['ema_200'], 'trend'] = "Baixa" trends[tf] = df['trend'].iloc[-1] return trends

    Inicializar dados para múltiplos timeframes

    timeframes = { "M15": mt5.TIMEFRAME_M15, "M30": mt5.TIMEFRAME_M30, "H1": mt5.TIMEFRAME_H1, "H4": mt5.TIMEFRAME_H4, "D1": mt5.TIMEFRAME_D1 # Adicionar D1 para Diário } data_multiple = get_data_multiple_timeframes(symbol, timeframes, 1000)

    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"

    Função para analisar múltiplos ativos ao iniciar o software

    def analyze_multiple_assets(): symbols = ["EURUSD", "GBPUSD", "USDJPY", "USDCHF", "AUDUSD", "USDCAD", "NZDUSD", "GOLD", "BTCUSD", "US500Cash", "US30Cash"] analysis = {}

    for symbol in symbols:
        mt5.symbol_select(symbol, True)
        data = get_data(symbol, timeframe, 1000)
        data = apply_technical_indicators(data)
        data = calculate_volatility(data)
        data = determine_trend(data)
        signals = detect_signals(data)
    
        # Determinar volatilidade e tendência atuais
        volatility_state = get_volatility_state(data)
        trend_state = data['trend'].iloc[-1]
        signal_state = signals[-1]['signal'] if signals else 0
        
        # Adicionar o resultado da análise ao dicionário
        analysis[symbol] = {
            'volatility': volatility_state,
            'trend': trend_state,
            'signal': 'Compra' if signal_state == 1 else 'Venda' if signal_state == -1 else 'Neutro'
        }
    
    return analysis
    

    Inicializar análise de múltiplos ativos

    multiple_assets_analysis = analyze_multiple_assets()

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

    fig.canvas.manager.set_window_title('Indicator Smart Money Pro by Wendel C') # Define o título da janela fig.canvas.manager.window.iconbitmap('') # Define o ícone da janela como vazio para remover o ícone

    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000) plt.draw() # Force an initial draw plt.show()

  2. Assistant

    A sua mensagem de erro está apontando para alguns problemas relacionados com a manipulação de cópias e visualizações de DataFrames do pandas. Esses problemas são comuns quando você está tentando modificar um DataFrame que é uma cópia de outro. Essa situação pode levar a um comportamento inesperado nos seus dados. Vamos abordar os problemas principais que são a causa dos warnings e do erro TypeError.

    Resolução dos problemas:

    1. Evitar o SettingWithCopyWarning

    O SettingWithCopyWarning ocorre quando você tenta modificar uma cópia de uma fatia de um DataFrame. Uma maneira de resolver isso é utilizando .loc para garantir que você está trabalhando de fato no DataFrame original.

    Aqui está um exemplo de como você pode resolver isso:

    data.loc[i, 'choch'] = -1
    

    Ao invés de:

    data['choch'][i] = -1
    

    Vamos adaptar sua função detect_bos_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.loc[i, 'bos'] = 1
            elif data['high'][i] < data['high'][i-1] and data['low'][i] < data['low'][i-1]:
                data.loc[i, 'bos'] = -1
            if data.loc[i, 'bos'] == 1 and data.loc[i-1, 'bos'] == -1:
                data.loc[i, 'choch'] = 1
            elif data.loc[i, 'bos'] == -1 and data.loc[i-1, 'bos'] == 1:
                data.loc[i, 'choch'] = -1
        return data
    

    2. Resolução do TypeError em detect_swing_points

    Esse erro ocorre porque você está tentando converter um objeto Timestamp para int, o que não é permitido. Para resolver isso, não converta diretamente o índice, ao invés disso, use o método .get_loc() do índice para obter a localização do índice:

    Vamos modificar a função detect_swing_points:

    def detect_swing_points(data, window=20):
        # Rolling não aplica diretamente sobre os índices, então criamos diretamente na série
        highest_idx = data['high'].rolling(window=window).apply(lambda x: np.argmax(x), raw=True)
        lowest_idx = data['low'].rolling(window=window).apply(lambda x: np.argmin(x), raw=True)
        
        # Pegando os valores correspondentes na série de índices do DataFrame
        swing_high = data['high'].iloc[int(highest_idx.iloc[-1])]
        swing_low = data['low'].iloc[int(lowest_idx.iloc[-1])]
    
        return swing_high, swing_low
    

    3. Ajuste Final no Código com .loc e .iloc

    Como orientação geral:

    • Utilize data.loc[index, column] para indexação baseada em rótulos.
    • Utilize data.iloc[index, column] para indexação baseada em posição.

    Aplicando essas mudanças ao restante do seu código

    Certifique-se de revisar outras partes onde você manipula o DataFrame diretamente para evitar problemas de cópia de fatias.

    Após essas alterações, faça uma nova rodada de testes para garantir que os warnings e erros foram resolvidos e o comportamento do seu código é o esperado.

  3. User

    nao entendi onde muda essa parte

    3. Ajuste Final no Código com .loc e .iloc

    Como orientação geral:

    • Utilize data.loc[index, column] para indexação baseada em rótulos.
    • Utilize data.iloc[index, column] para indexação baseada em posição.
  4. Assistant

    Claro, vamos aprofundar um pouco mais na questão das modificações com .loc e .iloc. É importante entender cada um desses métodos para garantir que seu código esteja acessando e manipulando os dados de maneira eficiente e correta.

    Diferenciação entre .loc e .iloc

    • .loc: Usado para acessar um grupo de filas e colunas por rótulo(s) ou uma matriz booleana.
    • .iloc: Usado para acessar um grupo de filas e colunas por posições inteiras (índices baseados em zero).

    Exemplo de Uso

    1. loc

    Se você quiser acessar ou modificar um valor baseado no rótulo (index label), você usa .loc:

    # Modificar uma célula específica baseado no índice e coluna
    data.loc[index_label, 'coluna'] = valor
    
    # Exemplo prático
    data.loc['2023-10-01', 'close'] = 1000  # Define o valor 1000 para a coluna 'close' na linha com rótulo '2023-10-01'
    

    2. iloc

    Se você quiser acessar ou modificar um valor baseado na posição (index position), você usa .iloc:

    # Modificar uma célula específica baseado na posição da linha e coluna
    data.iloc[index_position, coluna_position] = valor
    
    # Exemplo prático
    data.iloc[0, 3] = 1000  # Define o valor 1000 para a célula na primeira linha e quarta coluna
    

    Aplicação ao Seu Código

    Vamos garantir que estamos usando .loc e .iloc corretamente em todo o seu código para evitar o SettingWithCopyWarning e outros erros.

    Exemplo com .loc em detect_bos_choch:

    Antes:

    data['choch'][i] = -1  # Isso causa o SettingWithCopyWarning
    

    Depois:

    data.loc[i, 'choch'] = -1  # Acerto com .loc
    

    Corrigindo outras partes do código

    Reviso as alterações que foram propostas anteriormente em áreas onde provavelmente você encontrará problemas. Vamos garantir que todas as possíveis manipulações usando indexação sejam corrigidas.

    Correções específicas

    Função detect_bos_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.loc[i, 'bos'] = 1
            elif data['high'][i] < data['high'][i-1] and data['low'][i] < data['low'][i-1]:
                data.loc[i, 'bos'] = -1
            if data.loc[i, 'bos'] == 1 and data.loc[i-1, 'bos'] == -1:
                data.loc[i, 'choch'] = 1
            elif data.loc[i, 'bos'] == -1 and data.loc[i-1, 'bos'] == 1:
                data.loc[i, 'choch'] = -1
        return data
    

    Função detect_swing_points:

    Antes:

    swing_high = data['high'].iloc[int(swing_high_idx)]
    swing_low = data['low'].iloc[int(swing_low_idx)]
    

    Depois:

    swing_high = data['high'].iloc[int(swing_high_idx)]
    swing_low = data['low'].iloc[int(swing_low_idx)]
    

    A função detect_swing_points que você está usando já parece correta quanto ao uso de .iloc, mas você precisa garantir que os índices não são Timestamp. Se os índices de tempo não são números inteiros, considere converter para inteiros de maneira segura.

    Trabalhando no DataFrame Original

    No geral, ao trabalhar com Pandas, é uma boa prática simplesmente evitar a modificação de fatias diretamente obtidas com .loc ou .iloc sem uma cópia explícita, exceto em casos em que a alteração é absolutamente necessária e você está consciente do comportamento.

    Assim, sempre utilize o acesso direto ao DataFrame original ou crie uma cópia explícita quando necessário:

    data_copy = data.copy()
    
    # Trabalhe na cópia
    data_copy.loc[index_label, 'column'] = value
    
    # Depois substitua o DataFrame original
    data = data_copy
    

    Aplicando as modificações no contexto do seu código

    Fique atento a todas as partes do seu código onde a manipulação direta de valores de DataFrame está ocorrendo e ajuste de acordo.

    Revise cada função que manipula dados para assegurar o uso correto de .loc e .iloc. Se você encontrar outro erro ou warning específico, sinta-se à vontade para mostrar a seção problemática e eu poderei ajudar a ajustar a solução.

  5. User

    See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy data['fvg'][i] = data['low'][i-1] - data['high'][i] Traceback (most recent call last): File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\core\indexes\base.py", line 3653, in get_loc return self._engine.get_loc(casted_key) File "pandas_libs\index.pyx", line 147, in pandas._libs.index.IndexEngine.get_loc File "pandas_libs\index.pyx", line 176, in pandas._libs.index.IndexEngine.get_loc File "pandas_libs\hashtable_class_helper.pxi", line 7080, in pandas._libs.hashtable.PyObjectHashTable.get_item File "pandas_libs\hashtable_class_helper.pxi", line 7088, in pandas._libs.hashtable.PyObjectHashTable.get_item KeyError: 0

    The above exception was the direct cause of the following exception:

    Traceback (most recent call last): File "Smart_Money_Updated_04.py", line 445, in multiple_assets_analysis = analyze_multiple_assets() File "Smart_Money_Updated_04.py", line 428, in analyze_multiple_assets signals = detect_signals(data) File "Smart_Money_Updated_04.py", line 190, in detect_signals data = detect_bos_choch(data) File "Smart_Money_Updated_04.py", line 95, in detect_bos_choch if data.loc[i, 'bos'] == 1 and data.loc[i-1, 'bos'] == -1: File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\core\indexing.py", line 1096, in getitem return self.obj._get_value(*key, takeable=self._takeable) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\core\frame.py", line 3877, in _get_value row = self.index.get_loc(index) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\core\indexes\base.py", line 3655, in get_loc raise KeyError(key) from err KeyError: 0 PS H:\Tudo Sobre Python Software\SMART MONEY\Ultima Versao\O Melhor ate agora\Com Liquidez\PARA_VENDAS\Ultima Versão para Vendas\Uso Pessoal sem HWID>

  6. Assistant

    Os erros que você está encontrando sugerem problemas com a manipulação e a indexação de DataFrames no Pandas. Vamos resolver esses problemas passo a passo.

    1. Manipulações com .loc e .iloc

    Para evitar o SettingWithCopyWarning, você sempre deve usar .loc ou .iloc para modificar valores no DataFrame. A modificação direta como em data['fvg'][i] não é segura. Além disso, precisamos garantir que todos os indexadores sejam válidos.

    2. Tratamento do KeyError e SettingWithCopyWarning

    Para abordar o KeyError, parece que há um problema ao acessar um índice em sua DataFrame. A razão pode ser que os índices fornecidos não existem ou você está usando a indexação de forma incorreta.

    Vamos revisar e corrigir seu código.

    Função calculate_fvg:

    Corrigindo possíveis problemas de fatiamento e indexação:

    def calculate_fvg(data):
        data['fvg'] = 0  # Inicializa a coluna
        for i in range(1, len(data) - 1):
            if data['high'].iloc[i] < data['low'].iloc[i - 1]:
                data.loc[data.index[i], 'fvg'] = data['low'].iloc[i - 1] - data['high'].iloc[i]
            elif data['low'].iloc[i] > data['high'].iloc[i - 1]:
                data.loc[data.index[i], 'fvg'] = data['low'].iloc[i] - data['high'].iloc[i - 1]
        return data
    

    Função detect_bos_choch:

    Corrigindo o acesso do DataFrame para evitar KeyError:

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

    Função detect_swing_points:

    Já que o índice i nunca deve ser um Timestamp, vamos garantir que você está acessando os dados corretamente:

    def detect_swing_points(data, window=20):
        highest_idx = data['high'].rolling(window=window).apply(lambda x: np.argmax(x), raw=True).index[-1]
        lowest_idx = data['low'].rolling(window=window).apply(lambda x: np.argmin(x), raw=True).index[-1]
        
        swing_high = data['high'].loc[highest_idx]
        swing_low = data['low'].loc[lowest_idx]
    
        return swing_high, swing_low
    

    Função plot_chart_with_signals:

    Revisei sua função plot_chart_with_signals para garantir que detect_swing_points é chamado corretamente:

    def plot_chart_with_signals(i):
        global data, last_signal_index, data_multiple, multiple_assets_analysis, active_fibo, active_signal
        update_data()
    
        signals = detect_signals(data)
        data = calculate_volatility(data)
        data = determine_trend(data)
        data = calculate_trend_strength(data)
        volatility_state = get_volatility_state(data)
    
        fig.suptitle(f'Gráfico Indicador Smart Money Concept - {symbol}', fontsize=10, fontweight='bold')
    
        ax1.clear()
        ax2.clear()
    
        fig.text(0.5, 0.92, volatility_state, ha='center', va='top', fontsize=10, fontweight='bold')  # Ajuste os valores de x, y, ha, e va conforme necessário
    
        trends_multiple = determine_trend_multiple_timeframes(data_multiple)
        trend_message = f"M15: {trends_multiple['M15']}, M30: {trends_multiple['M30']}, H1: {trends_multiple['H1']}, H4: {trends_multiple['H4']}, D1: {trends_multiple['D1']}"
        fig.text(0.2, 0.93, trend_message, color="green", ha="center", va="center", fontsize=6, fontweight='normal')
    
        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
    
        for signal in signals:
            if signal["signal"] == 1:
                ax1.scatter(signal['index'], signal['open_price'], marker="^", color="green", label="Compra")
                ax1.text(signal['index'], signal['open_price'], f"Open: {signal['open_price']:.5f}\nTP: {signal['tp']:.5f}\nSL: {signal['sl']:.5f}", fontsize=10, ha="center", va="bottom", color="green")
                if last_signal_index is None or signal['index'] > last_signal_index:
                    new_signals_detected = True
            elif signal["signal"] == -1:
                ax1.scatter(signal['index'], signal['open_price'], marker="v", color="red", label="Venda")
                ax1.text(signal['index'], signal['open_price'], f"Open: {signal['open_price']:.5f}\nTP: {signal['tp']:.5f}\nSL: {signal['sl']:.5f}", fontsize=10, ha="center", va="top", color="red")
                if last_signal_index is None or signal['index'] > last_signal_index:
                    new_signals_detected = True
    
            if "liquidity_message" in signal:
                ax1.text(signal['index'], data["high"].loc[signal['index']], signal["liquidity_message"], color="blue", ha="left")
    
        trend_message = f"Tendência: {data['trend'].iloc[-1]}, Força: {data['trend_strength_label'].iloc[-1]}"
        fig.text(0.5, 0.93, trend_message, color="blue", ha="center", va="center", fontsize=10, fontweight='normal')
    
        if signals:
            last_signal_index = signals[-1]['index']
    
        
        if new_signals_detected:
            for _ in range(3):
                winsound.Beep(1000, 500)
    
        # Se não há sinal ativo ou o sinal foi cancelado, detectar um novo sinal
        if active_signal is None:
            # Detectar pontos de swing high e swing low
            swing_high, swing_low = detect_swing_points(data)
            
            # Calcular níveis de Fibonacci
            active_fibo = calculate_fibo_levels(swing_high, swing_low)
            
            # Detecção de sinais
            signals = detect_signals(data)
    
            # Selecionar o último sinal gerado
            if signals:
                active_signal = signals[-1]
    
        # Se há um sinal ativo, plotar os níveis de Fibonacci e verificar se o TP ou SL foi atingido
        if active_signal:
            for level_name, level_value in active_fibo.items():
                ax1.axhline(level_value, color='blue', linestyle='–')
                ax1.text(data.index[-1], level_value, f'{level_name}: {level_value:.5f}', fontsize=8, ha='right', color='blue')
            
            # Plotar o sinal ativo
            if active_signal["signal"] == 1:
                ax1.scatter(active_signal['index'], active_signal['open_price'], marker="^", color="green", label="Compra")
                ax1.text(active_signal['index'], active_signal['open_price'], f'{active_signal["open_price"]:.5f}', fontsize=8, ha="center", va="bottom", color="green")
            elif active_signal["signal"] == -1:
                ax1.scatter(active_signal['index'], active_signal['open_price'], marker="v", color="red", label="Venda")
                ax1.text(active_signal['index'], active_signal['open_price'], f'{active_signal["open_price"]:.5f}', fontsize=8, ha="center", va="top", color="red")
    
            # Verificar se o TP ou SL do sinal ativo foi atingido
            high_prices = data.loc[active_signal['index']:, 'high']
            low_prices = data.loc[active_signal['index']:, 'low']
            if active_signal["signal"] == 1 and (high_prices >= active_fibo['-0.27 (TP1)']).any():
                active_signal = None
            elif active_signal["signal"] == 1 and (low_prices <= active_fibo['1.13 (SL)']).any():
                active_signal = None
            elif active_signal["signal"] == -1 and (low_prices <= active_fibo['-0.27 (TP1)']).any():
                active_signal = None
            elif active_signal["signal"] == -1 and (high_prices >= active_fibo['1.13 (SL)']).any():
                active_signal = None
    
        ax1.set_xlabel("Data")
        ax1.set_ylabel("Preço")
        ax1.legend(loc="upper left")
        ax1.grid(True)
        ax1.xaxis.set_major_formatter(mdates.DateFormatter("%d-%m-%Y\n%H:%M"))
        plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45, ha="right", rotation_mode="anchor", fontsize=6)
    
        ax2.plot(data.index, data["volatility"], label="Volatilidade")
        ax2.set_xlabel("Data")
        ax2.set_ylabel("Volatilidade")
        ax2.legend(loc="upper left")
        ax2.grid(True)
    

    Conclusão

    Revise e ajuste seu código para usar .loc e .iloc adequadamente, garantindo que os índices sejam tratados corretamente para evitar problemas como SettingWithCopyWarning e KeyError. Após essas mudanças, teste novamente seu script para confirmar que os problemas foram resolvidos. Se novos erros surgirem ou se houver outras questões específicas, sinta-se à vontade para compartilhar, assim posso ajudar mais detalhadamente.

  7. User

    mart_Money_Updated_04.py:447: UserWarning: frames=None which we can infer the length of, did not pass an explicit save_count and passed cache_frame_data=True. To avoid a possibly unbounded cache, frame data caching has been disabled. To suppress this warning either pass cache_frame_data=False or save_count=MAX_FRAMES. ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000) Traceback (most recent call last): File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\cbook_init_.py", line 314, in process func(*args, **kwargs) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\animation.py", line 904, in _start self._init_draw() File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\animation.py", line 1748, in _init_draw self._draw_frame(frame_data) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\animation.py", line 1767, in _draw_frame self._drawn_artists = self._func(framedata, *self._args) File "Smart_Money_Updated_04.py", line 331, in plot_chart_with_signals ax1.axhline(level_value, color='blue', linestyle='–') File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\axes_axes.py", line 772, in axhline l = mlines.Line2D([xmin, xmax], [y, y], transform=trans, **kwargs) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib_api\deprecation.py", line 454, in wrapper return func(*args, **kwargs) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\lines.py", line 360, in init self.set_linestyle(linestyle) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib\lines.py", line 1170, in set_linestyle _api.check_in_list([*self.lineStyles, *ls_mapper_r], ls=ls) File "C:\Users\Wendel\AppData\Local\Programs\Python\Python38\lib\site-packages\matplotlib_api_init.py", line 131, in check_in_list raise ValueError(msg) ValueError: '–' is not a valid value for ls; supported values are '-', '--', '-.', ':', 'None', ' ', '', 'solid', 'dashed', 'dashdot', 'dotted'

  8. Assistant

    O que você está enfrentando são alguns erros específicos:

    1. Aviso de Matplotlib: Esse aviso está relacionado ao sistema de cache de animação do Matplotlib.
    2. Erro de Linestyle (linestyle): O caractere utilizado para definir o estilo da linha não é suportado pelo Matplotlib.

    Vamos abordar ambos os problemas.

    1. Aviso de Matplotlib sobre cache de quadro

    Para resolver o aviso sobre cache de quadro, você pode suprimir o aviso passando explicitamente cache_frame_data=False ou save_count.

    Abaixo está a modificação sugerida para a linha onde você inicializa FuncAnimation:

    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000, cache_frame_data=False)
    

    Ou, alternativamente, se você quiser controlar quantos frames estão sendo salvos em cache, pode utilizar save_count:

    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000, save_count=100)
    

    2. Erro de Linestyle (linestyle -)

    O segundo problema está no estilo da linha que você está tentando usar na chamada para ax1.axhline(). O caractere – (endash) não é suportado. Os valores válidos incluem: '-', '--', '-.', ':', 'None', ' ', '', 'solid', 'dashed', 'dashdot', 'dotted'.

    Vamos corrigir substituindo – por um valor suportado, como por exemplo '--' para uma linha tracejada:

    ax1.axhline(level_value, color='blue', linestyle='--')
    

    Aplicando as Correções

    Aqui está a linha completa do seu código com as correções aplicadas:

    # Inicializando FuncAnimation com cache_frame_data=False
    ani = FuncAnimation(fig, plot_chart_with_signals, interval=60000, cache_frame_data=False)
    
    # Função plot_chart_with_signals com o linestyle corrigido
    def plot_chart_with_signals(i):
        global data, last_signal_index, data_multiple, multiple_assets_analysis, active_fibo, active_signal
        update_data()
    
        signals = detect_signals(data)
        data = calculate_volatility(data)
        data = determine_trend(data)
        data = calculate_trend_strength(data)
        volatility_state = get_volatility_state(data)
    
        fig.suptitle(f'Gráfico Indicador Smart Money Concept - {symbol}', fontsize=10, fontweight='bold')
    
        ax1.clear()
        ax2.clear()
    
        fig.text(0.5, 0.92, volatility_state, ha='center', va='top', fontsize=10, fontweight='bold')
    
        trends_multiple = determine_trend_multiple_timeframes(data_multiple)
        trend_message = f"M15: {trends_multiple['M15']}, M30: {trends_multiple['M30']}, H1: {trends_multiple['H1']}, H4: {trends_multiple['H4']}, D1: {trends_multiple['D1']}"
        fig.text(0.2, 0.93, trend_message, color="green", ha="center", va="center", fontsize=6, fontweight='normal')
    
        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
    
        for signal in signals:
            if signal["signal"] == 1:
                ax1.scatter(signal['index'], signal['open_price'], marker="^", color="green", label="Compra")
                ax1.text(signal['index'], signal['open_price'], f"Open: {signal['open_price']:.5f}\nTP: {signal['tp']:.5f}\nSL: {signal['sl']:.5f}", fontsize=10, ha="center", va="bottom", color="green")
                if last_signal_index is None or signal['index'] > last_signal_index:
                    new_signals_detected = True
            elif signal["signal"] == -1:
                ax1.scatter(signal['index'], signal['open_price'], marker="v", color="red", label="Venda")
                ax1.text(signal['index'], signal['open_price'], f"Open: {signal['open_price']:.5f}\nTP: {signal['tp']:.5f}\nSL: {signal['sl']:.5f}", fontsize=10, ha="center", va="top", color="red")
                if last_signal_index is None or signal['index'] > last_signal_index:
                    new_signals_detected = True
    
            if "liquidity_message" in signal:
                ax1.text(signal['index'], data["high"].loc[signal['index']], signal["liquidity_message"], color="blue", ha="left")
    
        trend_message = f"Tendência: {data['trend'].iloc[-1]}, Força: {data['trend_strength_label'].iloc[-1]}"
        fig.text(0.5, 0.93, trend_message, color="blue", ha="center", va="center", fontsize=10, fontweight='normal')
    
        if signals:
            last_signal_index = signals[-1]['index']
    
        
        if new_signals_detected:
            for _ in range(3):
                winsound.Beep(1000, 500)
    
        # Se não há sinal ativo ou o sinal foi cancelado, detectar um novo sinal
        if active_signal is None:
            # Detectar pontos de swing high e swing low
            swing_high, swing_low = detect_swing_points(data)
            
            # Calcular níveis de Fibonacci
            active_fibo = calculate_fibo_levels(swing_high, swing_low)
            
            # Detecção de sinais
            signals = detect_signals(data)
    
            # Selecionar o último sinal gerado
            if signals:
                active_signal = signals[-1]
    
        # Se há um sinal ativo, plotar os níveis de Fibonacci e verificar se o TP ou SL foi atingido
        if active_signal:
            for level_name, level_value in active_fibo.items():
                ax1.axhline(level_value, color='blue', linestyle='--')  # Use um linestyle válido como '--'
                ax1.text(data.index[-1], level_value, f'{level_name}: {level_value:.5f}', fontsize=8, ha='right', color='blue')
            
            # Plotar o sinal ativo
            if active_signal["signal"] == 1:
                ax1.scatter(active_signal['index'], active_signal['open_price'], marker="^", color="green", label="Compra")
                ax1.text(active_signal['index'], active_signal['open_price'], f'{active_signal["open_price"]:.5f}', fontsize=8, ha="center", va="bottom", color="green")
            elif active_signal["signal"] == -1:
                ax1.scatter(active_signal['index'], active_signal['open_price'], marker="v", color="red", label="Venda")
                ax1.text(active_signal['index'], active_signal['open_price'], f'{active_signal["open_price"]:.5f}', fontsize=8, ha="center", va="top", color="red")
    
            # Verificar se o TP ou SL do sinal ativo foi atingido
            high_prices = data.loc[active_signal['index']:, 'high']
            low_prices = data.loc[active_signal['index']:, 'low']
            if active_signal["signal"] == 1 and (high_prices >= active_fibo['-0.27 (TP1)']).any():
                active_signal = None
            elif active_signal["signal"] == 1 and (low_prices <= active_fibo['1.13 (SL)']).any():
                active_signal = None
            elif active_signal["signal"] == -1 and (low_prices <= active_fibo['-0.27 (TP1)']).any():
                active_signal = None
            elif active_signal["signal"] == -1 and (high_prices >= active_fibo['1.13 (SL)']).any():
                active_signal = None
    
        ax1.set_xlabel("Data")
        ax1.set_ylabel("Preço")
        ax1.legend(loc="upper left")
        ax1.grid(True)
        ax1.xaxis.set_major_formatter(mdates.DateFormatter("%d-%m-%Y\n%H:%M"))
        plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45, ha="right", rotation_mode="anchor", fontsize=6)
    
        ax2.plot(data.index, data["volatility"], label="Volatilidade")
        ax2.set_xlabel("Data")
        ax2.set_ylabel("Volatilidade")
        ax2.legend(loc="upper left")
        ax2.grid(True)
    

    Conclusão

    Com essas mudanças, você deve resolver tanto o aviso sobre o cache de quadro quanto o erro de estilo de linha inválido. Faça essas alterações e teste seu código novamente. Se encontrar novos problemas ou se precisar de mais esclarecimentos, sinta-se à vontade para perguntar.