Desenvolvimento do Kit de Ferramentas de Análise de Price Action (Parte 9): Fluxo Externo

Introdução

Os mercados financeiros podem ser complexos, frequentemente apresentando desafios para traders e analistas no processamento e na interpretação precisa de dados. Para superar esses desafios, diversas bibliotecas foram desenvolvidas para simplificar a análise de mercado, cada uma projetada para lidar com dados de maneiras que se alinham a objetivos específicos. Embora as bibliotecas MQL5 sejam comumente usadas para criar estratégias de trading e indicadores, bibliotecas externas, como as ferramentas de análise de dados do Python, fornecem recursos adicionais para análises mais avançadas e aprofundadas.

Em artigos anteriores, concentrei-me em price action e análise de dados, explorando principalmente a geração de sinais por meio de cálculos e métricas processadas por Expert Advisors (EAs) em MQL5. Esses artigos, no entanto, estavam restritos à análise baseada em MQL5. Este artigo marca uma mudança ao introduzir a integração de bibliotecas externas especificamente projetadas para análise avançada de dados. Ao utilizar a biblioteca Python, Pandas, podemos explorar novos caminhos para os traders, oferecendo uma gama mais ampla de opções analíticas para atender a diferentes necessidades.

Este método não substitui o MQL5, mas o posiciona como o núcleo deste sistema. O EA em MQL5 atua como uma ponte, permitindo a interação com bibliotecas externas e servidores para construir uma estrutura analítica mais robusta e flexível. Gostaria de enfatizar que este artigo é apenas o início da exploração de análises avançadas, e aguardo apresentar percepções e técnicas mais abrangentes em discussões futuras.

Vamos dar uma olhada em como abordaremos esta tarefa:

• Visão Geral da Estratégia
• Python
• Principais Funções do EA em MQL5
• Resultados
• Conclusão

Visão Geral da Estratégia

O principal objetivo deste sistema é gerar um sinal de negociação utilizando a biblioteca Pandas do Python, aproveitando seus recursos de interpretação de dados. Nesta seção, analisaremos mais de perto como a lógica central é executada pelo sistema. Toda a troca ocorre entre o Expert Advisor (EA) em MQL5 e o Python, com vários processos acontecendo entre eles antes que o sinal seja finalmente exibido no gráfico. Vamos seguir as etapas descritas abaixo para entender como o sistema funciona.

1. MQL5 EA para Python:

• O Expert Advisor em MQL5 coleta a máxima, mínima, abertura, fechamento e volume do dia anterior, referentes a 10 dias. 
• Envia os dados para o servidor Python. 
• Formata os dados em uma string CSV e os envia por meio de uma solicitação HTTP POST para o servidor Python.

2. Python:

• O Python recebe os dados e processa as informações recebidas usando bibliotecas como o Pandas. 
• Analisa os dados para gerar um sinal de negociação, preço médio e volume, e então cria uma explicação.

3. Python para EA:

• O Python envia o sinal gerado, o preço médio, o volume e a explicação de volta ao EA em MQL5 por meio de uma resposta HTTP.

4. Expert Advisor em MQL5:

• O EA em MQL5 recebe e analisa a resposta, extraindo o sinal, o preço médio, o volume médio e a explicação da resposta. 
• Se o sinal for diferente, atualiza o gráfico com o novo sinal e o exibe.

Vamos consultar o diagrama a seguir para obter mais detalhes.

Fig 1. Gráfico Lógico

Python

Python é uma linguagem de programação versátil, reconhecida por sua simplicidade e ampla gama de aplicações. Ela é comumente utilizada para análise de dados, aprendizado de máquina, desenvolvimento web e automação, entre outras tarefas. Neste sistema, o Python é crucial para a execução de análises avançadas de dados, particularmente por meio de bibliotecas como o Pandas, que fornecem ferramentas eficientes para manipulação e análise de dados. O Python também cria um servidor para a interação entre o MQL5 e suas bibliotecas. Ao utilizar o Python para processar conjuntos de dados complexos, o sistema gera sinais de negociação com base em dados históricos de mercado, que são então enviados ao Expert Advisor (EA) em MQL5 para auxiliar nas decisões de negociação ao vivo. 

Vou orientá-lo pelo processo de instalação do Python, criação de um script e execução passo a passo.

• Baixe o instalador do Python acessando o site oficial do Python
•  Execute o Instalador

Importante: certifique-se de marcar a opção “Add Python to PATH” antes de clicar em Install Now. Isso facilita a execução do Python a partir da linha de comando.

•  Conclua a Instalação

O instalador iniciará o processo de instalação. Aguarde até que seja concluído. Quando a instalação terminar, clique em Close.

•  Verifique a Instalação

Abra o Prompt de Comando (pressione Windows + R, digite cmd e pressione Enter). Digite python --version e pressione Enter. Se o Python estiver instalado corretamente, você verá a versão do Python exibida (por exemplo, Python 3.x.x).

Após a instalação bem-sucedida do Python, considere agora instalar o Flask e o Pandas. O Flask é um framework web leve para Python usado para criar aplicações web. Ele foi projetado para ser simples, flexível e fácil de usar. O Flask está sendo utilizado para configurar um servidor web simples que permite a comunicação entre o Expert Advisor (EA) em MQL5 e as ferramentas de análise de dados em Python. O EA envia dados para o Flask (via solicitações HTTP), que processa os dados usando bibliotecas Python, neste caso o Pandas, e retorna um sinal de negociação ao EA.

Para instalar o Flask e o Pandas usando o Prompt de Comando, siga estas etapas:

Abra o Prompt de Comando

• Pressione Windows + R, digite cmd e pressione Enter.

Certifique-se de que o pip (Instalador de Pacotes do Python) esteja instalado

• Primeiro, verifique se o pip (gerenciador de pacotes do Python) está instalado executando:

pip --version

• Se o pip estiver instalado, você verá o número da versão. Caso não esteja instalado, você pode seguir as etapas abaixo para instalá-lo. O PIP (Python Package Installer) geralmente é instalado automaticamente junto com o Python. Se o PIP não estiver instalado, baixe o get-pip.py e execute-o usando o comando python get-pip.py.

Instalar Flask

• Para instalar o Flask, execute o seguinte comando no Prompt de Comando:

pip install Flask

• Aguarde a conclusão da instalação. O Flask será instalado e estará pronto para uso.

Instalar Pandas

• Para instalar o Pandas, execute este comando:

pip install pandas

• Da mesma forma, aguarde a conclusão da instalação.

Verificar Instalação

• Após instalar ambos os pacotes, você pode verificar a instalação executando estes comandos:

python -c "import flask; print(flask.__version__)"

python -c "import pandas; print(pandas.__version__)"

• Isso deve exibir as versões instaladas do Flask e do Pandas, confirmando que foram instalados com sucesso.

Agora você pode prosseguir para a criação de um script em Python. Pessoalmente, prefiro usar o Notepad++ para essa tarefa. Para criar o script, abra o Notepad++, inicie um novo arquivo e defina a linguagem como Python selecionando-a no menu Language. Depois de escrever o script, salve-o em um diretório de fácil localização. Certifique-se de salvar o arquivo com a extensão .py, que o identifica como um script Python.

Script Python

import pandas as pd
import flask
from flask import request, jsonify

app = flask.Flask(__name__)
app.config["DEBUG"] = True

@app.route('/analyze', methods=['POST'])
def analyze_csv():
    try:
        # Read CSV data from the POST request
        csv_data = request.data.decode('utf-8')

        # Write the CSV data to a file (optional, for debugging)
        with open('received_data.csv', 'w') as file:
            file.write(csv_data)

        # Load the CSV data into a DataFrame
        from io import StringIO
        data = StringIO(csv_data)
        df = pd.read_csv(data)

        # Ensure the CSV has the correct columns
        required_columns = ['date', 'prev_high', 'prev_low', 'prev_open', 'prev_close', 'prev_volume']
        for column in required_columns:
            if column not in df.columns:
                return jsonify({"error": f"Missing column: {column}"}), 400

        # Print the received metrics for debugging
        print("Received metrics:")
        print(df)

        # Perform analysis (Example: Calculate average price and volume)
        df['average_price'] = (df['prev_high'] + df['prev_low'] + df['prev_open'] + df['prev_close']) / 4
        average_price = df['average_price'].mean()  # Average of all the average prices
        average_volume = df['prev_volume'].mean()  # Average volume

        # Print the computed averages
        print(f"Average Price: {average_price}")
        print(f"Average Volume: {average_volume}")

        # Create a trading signal based on a simple rule
        last_close = df['prev_close'].iloc[-1]
        if last_close > average_price:
            signal = "BUY"
            signal_explanation = f"The last close price ({last_close}) is higher than the average price ({average_price})."
        else:
            signal = "SELL"
            signal_explanation = f"The last close price ({last_close}) is lower than the average price ({average_price})."

        # Print the signal and explanation
        print(f"Generated Signal: {signal}")
        print(f"Signal Explanation: {signal_explanation}")

        # Return the signal as JSON
        return jsonify({
            "signal": signal,
            "average_price": average_price,
            "average_volume": average_volume,
            "signal_explanation": signal_explanation
        })

    except Exception as e:
        return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
    app.run(host='189.7.6.8', port=5877)

Para executar o script, abra o Prompt de Comando no seu computador.

Execute o comando:

cd C:\Userscaminho para a pasta do seu script python

Seguido pelo comando:

python filename.py

Use exatamente o nome que você atribuiu ao seu script ao executá-lo. Quando o script for executado, ele indicará que a porta está ativamente em escuta.

 Running on http://189.7.6.8:5877

Funções Principais

Inicialização (OnInit)

Esta função é executada quando o EA é inicializado pela primeira vez na plataforma MetaTrader. Ela é usada para configurar quaisquer recursos ou configurações necessárias ao EA. Neste caso, ela simplesmente imprime uma mensagem no log indicando que o EA está pronto para iniciar a interação com o servidor Python.

int OnInit()
{
   Print("Expert initialized. Ready to send data to Python.");
   return(INIT_SUCCEEDED);
}

O valor de retorno INIT_SUCCEEDED indica que a inicialização foi bem-sucedida.

Desinicialização (OnDeinit)

Esta função é acionada quando o EA é removido ou quando a plataforma MetaTrader é fechada. Normalmente, ela é usada para operações de limpeza, como liberação de recursos ou fechamento de arquivos abertos. Aqui, ela simplesmente imprime uma mensagem indicando que o EA foi desinicializado e não está mais ativo.

void OnDeinit(const int reason)
{
   Print("Expert deinitialized.");
}

OnTick (Funcionalidade Principal)

Esta é a função principal do EA que é executada toda vez que as condições de mercado mudam (a cada novo tick).

void OnTick()
{
   // Check if enough time has passed since the last signal update
   if(TimeCurrent() - lastSignalTime < signalInterval)
   {
      return;  // Skip if it's too soon to update
   }

   // Collect data and prepare CSV for Python
   string csvData = "date,prev_high,prev_low,prev_open,prev_close,prev_volume\n";

   // Get the previous trend data for the last `trendDays`
   for(int i = 1; i <= 10; i++)  // You can adjust the trendDays here
   {
      datetime prevDate = iTime(Symbol(), PERIOD_D1, i);
      double prevHigh = iHigh(Symbol(), PERIOD_D1, i);
      double prevLow = iLow(Symbol(), PERIOD_D1, i);
      double prevOpen = iOpen(Symbol(), PERIOD_D1, i);
      double prevClose = iClose(Symbol(), PERIOD_D1, i);
      long prevVolume = iVolume(Symbol(), PERIOD_D1, i);

      csvData += StringFormat("%s,%.5f,%.5f,%.5f,%.5f,%ld\n",
                              TimeToString(prevDate, TIME_DATE | TIME_MINUTES),
                              prevHigh, prevLow, prevOpen, prevClose, prevVolume);
   }

   // Save data to CSV file
   string fileName = StringFormat("%s_analytics.csv", Symbol());
   int fileHandle = FileOpen(fileName, FILE_WRITE | FILE_CSV | FILE_ANSI);
   if(fileHandle != INVALID_HANDLE)
   {
      FileWriteString(fileHandle, csvData);
      FileClose(fileHandle);
      Print("CSV file created: ", fileName);
   }
}

Ela também executa as seguintes operações:

• Verificação do Intervalo de Sinal: O EA primeiro verifica se tempo suficiente passou desde a última atualização do sinal usando TimeCurrent(). Caso contrário, ele ignora o processamento.
• Coleta de Dados: O EA coleta dados de mercado dos últimos 10 dias (ou mais, se você alterar o valor no loop), incluindo: máxima, mínima, abertura, fechamento e volume do dia anterior.
• Formatação de Dados: Em seguida, ele formata esses dados em formato CSV para facilitar a transmissão ao servidor Python. 
• Salvamento do Arquivo CSV: Os dados são salvos como um arquivo .csv com o nome <symbol>_analytics.csv no disco. Se a criação e gravação do arquivo forem bem-sucedidas, uma mensagem de sucesso é exibida.

Solicitação HTTP para o Servidor Python (WebRequest)

string headers = "Content-Type: application/json\r\n";
char result[];
string resultHeaders;
int responseCode = WebRequest(
    "POST",                  // HTTP method
    pythonUrl,               // URL
    headers,                 // Custom headers
    timeout,                 // Timeout in milliseconds
    data,                    // Data to send
    result,                  // Response content
    resultHeaders            // Response headers
);

if(responseCode == 200)
{
    string response = CharArrayToString(result);
    Print("Received response: ", response);
}
else
{
    Print("Error: HTTP request failed with code ", responseCode);
}

Após preparar os dados em formato CSV, o EA envia esses dados para um servidor Python via HTTP POST.

• Cabeçalhos: O cabeçalho Content-Type é definido como application/json, o que informa ao servidor que os dados enviados estão no formato JSON.
• WebRequest: A função WebRequest é utilizada para enviar a solicitação HTTP POST ao servidor Python. A função retorna:

1) responseCode: O código de resposta HTTP (por exemplo, 200 para sucesso).

2) result: O conteúdo da resposta do servidor (que normalmente consiste nos resultados da análise).

Fig 2. Fluxograma do WebRequest

• Se a solicitação for bem-sucedida (responseCode == 200), o conteúdo da resposta é convertido de um array de caracteres para uma string, e uma mensagem de sucesso é exibida. Se a solicitação falhar, uma mensagem de erro é exibida.

Análise e Exibição da Resposta

if(responseCode == 200)
{
    string signal = "";
    string avgPrice = "";
    string avgVolume = "";
    string explanation = "";

    // Extract signal, avgPrice, avgVolume, and explanation from the response
    int signalStart = StringFind(response, "\"signal\":");
    int signalEnd = StringFind(response, "\"average_price\":");
    int explanationStart = StringFind(response, "\"signal_explanation\":");
    int avgPriceStart = StringFind(response, "\"average_price\":");
    int avgVolumeStart = StringFind(response, "\"average_volume\":");

    if(signalStart != -1 && signalEnd != -1)
    {
        signal = StringSubstr(response, signalStart + 10, signalEnd - signalStart - 12);
    }

    if(explanationStart != -1)
    {
        explanation = StringSubstr(response, explanationStart + 23, StringFind(response, "\"", explanationStart + 23) - (explanationStart + 23));
    }

    if(avgPriceStart != -1)
    {
        avgPrice = StringSubstr(response, avgPriceStart + 16, StringFind(response, "\"", avgPriceStart + 16) - (avgPriceStart + 16));
    }

    if(avgVolumeStart != -1)
    {
        avgVolume = StringSubstr(response, avgVolumeStart + 18, StringFind(response, "\"", avgVolumeStart + 18) - (avgVolumeStart + 18));
    }

    // Update the chart if the signal has changed
    if(signal != lastSignal)
    {
        lastSignal = signal;
        lastSignalTime = TimeCurrent();  // Update last signal time
        string receivedSummary = "Signal: " + signal + "\n" +
                                 "Avg Price: " + avgPrice + "\n" +
                                 "Avg Volume: " + avgVolume + "\n" +
                                 "Explanation: " + explanation;
        Print("Received metrics and signal: ", receivedSummary);
        Comment(receivedSummary);  // Display it on the chart
    }
}

 Após receber a resposta do servidor Python, o EA analisa a resposta para extrair dados principais, tais como:

• Sinal: O sinal de negociação (por exemplo, "buy" ou "sell").
• Preço Médio: O preço médio derivado da análise.
• Volume Médio: O volume médio das negociações.
• Explicação: Uma explicação do motivo pelo qual o sinal foi gerado.

A função utiliza StringFind e StringSubstr para extrair esses valores da string de resposta.

Se o sinal tiver mudado desde a última atualização (signal != lastSignal), ela:

1) Atualiza as variáveis lastSignal e lastSignalTime.

2) Exibe o novo sinal, o preço médio, o volume e a explicação como um comentário no gráfico usando a função Comment().

Atualização e Exibição do Sinal

Esta parte está integrada à etapa anterior, onde o sinal é atualizado e exibido no gráfico.

if(signal != lastSignal)
{
    lastSignal = signal;
    lastSignalTime = TimeCurrent();  // Update last signal time
    string receivedSummary = "Signal: " + signal + "\n" +
                             "Avg Price: " + avgPrice + "\n" +
                             "Avg Volume: " + avgVolume + "\n" +
                             "Explanation: " + explanation;
    Print("Received metrics and signal: ", receivedSummary);
    Comment(receivedSummary);  // Display it on the chart
}

 Se o sinal tiver sido alterado (ou seja, se for diferente do anterior), o EA:

• Atualiza as variáveis lastSignal e lastSignalTime.
• Cria um resumo em formato de string contendo o sinal, o preço médio, o volume médio e a explicação.
• Exibe o resumo no gráfico como um comentário e o imprime no log.

CharArrayToString (Função Utilitária)

string CharArrayToString(char &arr[])
{
    string result = "";
    for(int i = 0; i < ArraySize(arr); i++)
    {
        result += StringFormat("%c", arr[i]);
    }
    return(result);
}

Esta função utilitária é usada para converter um array de caracteres (recebido da resposta HTTP) em uma string. Ela percorre cada elemento do array de caracteres e adiciona o caractere correspondente à string de resultado.

Cada uma dessas etapas foi projetada para lidar com uma parte específica do processo: coleta de dados, envio ao servidor Python, recebimento da análise e atualização do gráfico com o sinal de negociação. Essa abordagem garante que o EA possa operar de forma autônoma, coletar dados relevantes do mercado e tomar decisões com base em análises impulsionadas pelo Python.

Resultados

O primeiro passo é confirmar que seu script Python está em execução e escutando ativamente no servidor necessário. Para instruções detalhadas sobre como configurar e executar o script, consulte a seção Python acima. Se estiver escutando ativamente, ele deverá exibir: 

Running on http://189.7.6.8:5877

Observe que a API e o host mencionados acima não são os reais utilizados, tendo sido gerados apenas para fins educacionais. Em seguida, prosseguimos para iniciar o EA em MQL5. Se a conexão entre o MQL5 e o servidor Python for estabelecida com sucesso, você verá mensagens de log na aba “Experts” do gráfico. Além disso, o script Python em execução no prompt de comando exibirá as métricas recebidas.

O Prompt de Comando exibirá o seguinte:

189.7.6.8 - - [21/Jan/2025 10:53:44] "POST /analyze HTTP/1.1" 200 -
Received metrics:
                date  prev_high  prev_low  prev_open  prev_close  prev_volume
0   2025.01.20 00:00    868.761   811.734    826.389     863.078      83086.0
1   2025.01.19 00:00    856.104   763.531    785.527     826.394      82805.0
2   2025.01.18 00:00    807.400   752.820    795.523     785.531      82942.0
3   2025.01.17 00:00    886.055   790.732    868.390     795.546      83004.0
4   2025.01.16 00:00    941.334   864.202    932.870     868.393      83326.0
5   2025.01.15 00:00    943.354   870.546    890.620     932.876      83447.0
6   2025.01.14 00:00    902.248   848.496    875.473     890.622      83164.0
7   2025.01.13 00:00    941.634   838.520    932.868     875.473      82516.0
8   2025.01.12 00:00    951.350   868.223    896.455     932.883      83377.0
9   2025.01.11 00:00    920.043   857.814    879.103     896.466      83287.0
10               NaN        NaN       NaN        NaN         NaN          NaN

As informações acima serão utilizadas pelo pandas para análise e geração de sinais. Os dados do décimo dia exibem “NaN” porque o dia ainda não foi encerrado, o que significa que a análise se baseia principalmente nos valores obtidos dos dias anteriores. No entanto, ela também incorpora os níveis de preço atuais do décimo dia, que ainda estão incompletos. Abaixo, você pode encontrar os logs e os resultados da análise exibidos pelo pandas no prompt de comando (CMD)

Average Price: 865.884525
Average Volume: 83095.4
Generated Signal: SELL
Signal Explanation: The last close price (nan) is lower than the average price (865.884525).

O MetaTrader 5 exibirá o seguinte:

Vamos começar verificando os registros na aba “Experts”. Consulte abaixo para visualizar os resultados obtidos.

2025.01.21 10:50:28.106 External Flow (Boom 300 Index,D1)       CSV file created: Boom 300 Index_analytics.csv
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)       Received response: {
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "average_price": 865.884525,
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "average_volume": 83095.4,
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "signal": "SELL",
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "signal_explanation": "The last close price (nan) is lower than the average price (865.884525)."

O resultado também será exibido no gráfico, e o processo se repetirá com base nas configurações de tempo limite especificadas nos parâmetros de entrada.

Fig 3. Resultado Exibido

Abaixo está um diagrama de uma negociação lucrativa que realizei com base no sinal gerado e em análises adicionais. A negociação é exibida no timeframe M1 (1 minuto) para maior clareza.

Fig 4. Transação realizada

Conclusão

Tendo descrito as etapas para implementar análises avançadas utilizando bibliotecas externas como o pandas neste projeto, acredito que estabelecemos uma base sólida para o desenvolvimento de ferramentas mais avançadas de price action e análise de mercado. Encorajo todos os traders a encarar isto como um guia geral para compreender movimentos de mercado antecipados. No entanto, para uma execução ideal das negociações, incorpore também outras estratégias com as quais você esteja familiarizado. Seus comentários e feedback são muito bem-vindos à medida que continuamos trabalhando na criação de ferramentas mais profissionais para análises avançadas de mercado.

Data	Nome da Ferramenta	Descrição	Versão	Atualizações	Notas
01/10/24	Projetor de Gráficos	Script para sobrepor a movimentação de preços do dia anterior com efeito fantasma.	1.0	Lançamento Inicial	Primeira ferramenta na caixa de ferramentas de Lynnchris
18/11/24	Comentário Analítico	Apresenta informações do dia anterior em formato de tabela, além de antecipar a direção futura do mercado.	1.0	Lançamento Inicial	Segunda ferramenta na caixa de ferramentas Lynnchris
27/11/24	Mestre em Análise	Atualização regular das métricas de mercado a cada duas horas	1.01	Segundo Lançamento	Terceira ferramenta na caixa de ferramentas Lynnchris
02/12/24	Previsor Analítico	Atualização regular das métricas de mercado a cada duas horas com integração ao Telegram	1.1	Terceira Edição	Ferramenta número 4
09/12/24	Navegador de Volatilidade	O EA analisa as condições de mercado usando os indicadores Bandas de Bollinger, RSI e ATR	1.0	Lançamento Inicial	Ferramenta número 5
19/12/24	Reversão à Média Ceifador de Sinal	Analisa o mercado usando a estratégia de reversão à média e fornece sinais	1.0	Lançamento Inicial	Ferramenta número 6
9/01/2025	Pulso de sinal	Analisador de múltiplos períodos de tempo	1.0	Lançamento Inicial	Ferramenta número 7
17/01/2025	Quadro de Métricas	Painel com botão para análise	1.0	Lançamento Inicial	Ferramenta número 8
21/01/2025	Fluxo externo	Análise por meio de bibliotecas externas	1.0	Lançamento Inicial	Ferramenta número 9