Simulação de mercado (Parte 14): Sockets (VIII)

Introdução

No artigo anterior Simulação de mercado (Parte 13): Sockets (VII), mostrei como você poderia conseguir fazer um servidor bastante simples em Python, em que fosse possível manter o código funcionando. Isto mesmo quando não houvesse nenhum tipo de atividade no soquete que o servidor estivesse observando. A parte interessante de tal implementação é que não foi necessário fazer uso de nenhuma thread.

Apesar de tudo, nada impediria que você usasse uma combinação entre o que foi visto no artigo passado e o anterior. Já que no anterior, mostrei como seria feito o mesmo tipo de servidor, mas usando um thread, uma vez que algum cliente viesse a se conectar. O fato de ambos métodos funcionarem, se deve a questão de que ambos são direcionados de forma a verem o soquete da mesma forma. Independentemente da quantidade de clientes conectados. Porém, tanto o modelo que utiliza um thread, quando o modelo que faz uso da função select.

Não são de fato adequados para serem usados na nossa implementação. Não por que eles são falhos e não funcionam. Longe disto. Mas o real motivo é que eles, da forma como o código foi feito, interferem no Excel. Tal interferência, faz com que o Excel e o script em Python, fiquem competindo no uso da CPU. Tornando o uso do Excel impraticável.

Muitos poderiam sugerir, que deveríamos abandonar o Excel, e usar o Python pura e simplesmente. Fazendo uso de alguns pacotes que permitiriam ao Python criar um arquivo de Excel, para que pudéssemos analisar os resultados depois. Mas como foi dito no artigo anterior, apesar desta solução ser a mais simples, pelo ponto de vista de muitos programadores. Ela de fato, não será bem vista, pelos olhos de alguns usuários. E nesta história toda, o usuário tem sempre razão. Você como programador deve, encontrar alguma forma ou alguma maneira de fazer as coisas funcionarem. Se não deu da forma como você vem tentando, é por que você ainda não tem o nível de conhecimento necessário. Procure estudar mais e se aprofundar no que rege o seu conhecimento.

Ficar apenas no básico, não lhe fará um programador de qualidade. Apenas irá lhe deixar como um programador dentro da média. E as coisas não evoluem por que todos estão na média. Elas evoluem por que alguns se destacam. E aqui neste artigo, quero mostrar como você poderia fazer para solucionar a questão do Excel e o Python. Então se acomode e vamos ver como fazer o Excel e o Python trabalharem juntos, sem ficar competindo um com o outro pelo uso da CPU.

Voltando aos primórdios

Muitos de vocês, que estão lendo este artigo, devem ter começado no Python a pouco tempo. Outros talvez já vem fazendo uso do Python já a algum tempo. Mas como grande parte faz uso massivo de pacotes populares. Acredito que poucos saibam realmente como e por que de usar o Python. Não vou explicar tal coisa aqui. Isto por que fugiria completamente do escopo desta sequência de artigos. A ideia desta sequência é mostrar como desenvolver um sistema de replay/simulador no MetaTrader 5. Mas como será preciso, usarmos algumas coisas, para promover um melhor uso do replay/simulador. Tivemos que dar uma pequena pausa no desenvolvimento do replay/simulador, para explicar sobre outros assuntos. Apesar de a primeira vista não parecerem relacionados ao sistema principal, que é o replay/simulador.

Muito bem. Para cumprir o nosso objetivo. Que é colocar um servidor sendo executado dentro do Excel, para poder transferir informações entre o Excel e o MetaTrader 5. Poderíamos usar o VBA para tal coisa. No entanto, usar o VBA para criar o tal servidor é algo bastante chato de ser feito. Isto por que, o servidor ficaria embutido completamente na planilha em que ele fosse criado. E no entanto, precisamos que ele possa ser usado em diversas planilhas diferentes. O motivo será visto no futuro. Mas não pense que fazer um servidor no VBA é algo complicado. Na verdade é simples, porém como eu mencionei, é algo chato. Já que teríamos que ficar replicado o código a todo momento.

Porém, ao fazer uso do Python, podemos criar muito facilmente o mesmo tipo de servidor que seria feito em VBA. Isto sem falar na possibilidade de usar C/C++ como foi visto em um artigo anterior. Mas usar o Python, é sem sombra de dúvida a maneira mais simples de fazer isto. No entanto, nos artigos anteriores, mostrei que usando uma programação simples, com uso de pacotes populares, isto não seria de fato algo prático. E o principal motivo, é o fato de que uma vez que o servidor esteja funcionando, ele fica competindo com o Excel no uso da CPU. Até mostrei como fazer uso de thread, a fim de mostrar como reduzir um pouco esta competição. Mas novamente, quando vamos fazer threads no VBA a coisa começa a ir para o lado chato da história. Onde precisamos ficar replicando o código a cada nova planilha que tiver que ser construída.

Então a solução é de fato implementar a maior parte do código em Python, e usar o mínimo do mínimo de código em VBA. E sim podemos e iremos fazer isto. Mas esteja ciente de que, tudo que será mostrado a partir deste ponto, pode vir a ser muito confuso. Então sugiro que você procure estudar o assunto com calma. Não use o código mostrado aqui, em um sistema de produção. Você pode até fazer isto, mas esteja ciente de que o código mostrado aqui, tem como objetivo ser apenas didático.

Entendendo um pouco sobre COM

Antes de começarmos, gostaria de lhe perguntar algumas coisas. Você sabe o que é COM? Já leu ou programou algo que usa-se OLE? Entende algo sobre .NET? Se para qualquer uma destas perguntas a resposta foi um não. Significa que você ainda está engatinhando na programação. Mas para o que precisamos aqui, apenas entender os conceitos e saber o básico de como trabalhar com COM já será o suficiente.

Muito bem, tal de COM vem de Componet Object Model. Ela foi criada pela Microsoft no início dos anos 90 a fim de permitir uma comunicação entre processos. Seria algo muito parecido com os soquetes. Porém com algumas vantagens. Ela iria permitir implementar esta comunicação independente da linguagem que fosse utilizada, da arquitetura ou equipamento. E isto sem que você como desenvolvedor, precisasse entender como a implementação fosse feita internamente. Já que você deixaria de olhar isto, e passaria a usar uma interface comum e bem definida.

Isto é o básico do básico sobre esta tal de COM. Mas por que ela é importante para nos, neste ponto do desenvolvimento? O motivo é que se fizermos uso desta tecnologia, podemos fazer com que o Python e o Excel funcionem em perfeita harmonia. Sem que eles entrem em conflito ou fiquem competindo para usar a CPU durante o processo de comunicação entre eles.

Mas é possível usar esta tal de COM no Python? Sim. E por incrível que pareça, você não vai precisar instalar nenhum pacote. Bastará entender um pouco sobre como as coisas funcionam em Python. Mas se você entender sobre esta tecnologia COM, as coisas ficaram bem mais simples. No final do artigo, deixarei uma referência para que você tenha por onde começar a estudar sobre COM. Assim como a referência para que você estude sobre o que será tratado aqui neste artigo.

Começando a programar em Python

A primeira coisa que faremos aqui, será algo bastante simples. Muitos diriam que podemos fazer a mesma coisa usando outros pacotes do Python. De fato eles não estão errados. Realmente é possível fazer a mesma coisa usando outros pacotes. Porém é preciso que você entenda, como as coisas realmente funcionam. Não vamos criar fumaça ou usar jogos de espelhos a fim de ocultar o que precisamos entender. Então vamos usar o Python na sua versão mais simples. Ou seja, se você apenas baixar e instalar o Python, sem nenhum pacote extra, conseguirá fazer as mesmas coisas que irei mostrar aqui. Lembrando que será preciso, que você tenha o Excel instalado na máquina. Mas isto é apenas um lembrete, já que acredito que tal fato seria obvio.

Muito bem, então vamos fazer o nosso primeiro código em Python usar esta tal de COM. Para isto, vamos fazer com que um script em Python, abra o Excel e coloque alguma informação em uma célula especifica. Parece complicado fazer isto sem nenhum daqueles pacotes extras, não é mesmo? Pois bem, se você pensou isto, é por que você ainda está engatinhando no aprendizado em Python. Pois é possível fazer isto, e sem aquela complicação toda de usar este ou aquele pacote. Então veja o código fonte, de um script que faz justamente isto. Este pode ser visto logo abaixo.

1. from win32com import client as win32
2. 
3. excel = win32.Dispatch('Excel.Application')
4. excel.Visible = True
5. 
6. while True:
7.     pass

Código em Python

Se você executar este simples script acima. Irá ter como resultado o que é visto na imagem abaixo.

Agora você pode estar se perguntando: Mas onde está a planilha? Calma. Tudo que fizemos foi apenas abrir o Excel. Nada além disto. Mas observe como fizemos isto. Na linha um do script, dizemos o que vamos usar. Já na linha três, enviamos um pedido para que uma aplicação em Excel seja criada. Porém, ela será criada, mas ficará oculta. Para permitir que ela seja visível, usamos a linha quatro. Agora caso não façamos uso do laço na linha seis. A aplicação será aberta e logo depois fechada. A linha sete, apenas garante que o Python não irá ficar reclamando de que o laço esteja vazio.

Agora vamos adicionar um pouco mais de código neste script. É possível fazer as coisas de forma um pouco mais rápida. Mas quero que você, caro leitor, compreenda o que está acontecendo. Então vamos devagar. O próximo script pode ser visto logo abaixo.

1. from win32com import client as win32
2. 
3. excel = win32.Dispatch('Excel.Application')
4. excel.Visible = True
5. wb = excel.Workbooks.Add()
6. wb.Activate()
7. 
8. while True:
9.     pass

Código em Python

O resultado é visto na imagem abaixo.

Observe que foi adicionado duas linhas. A linha cinco e a linha seis. O que estamos fazendo neste momento, é usando o tal do COM. Nas referências no final deste artigo, você poderá ver e estudar melhor estas chamadas, a fim de fazer mais coisas usando esta tecnologia de programação COM. Isto pensando em fazer mais do que estarei mostrando aqui. Lembre-se: Aqui estarei mostrando o básico da coisa. Apenas o suficiente, para que você venha a ficar preparado e não fique boiando na próxima etapa. Então note, que abrimos o Excel. Tornamos ele visivel. Adicionamos uma planilha. E logo depois a tornamos ativa. Tudo ainda muito simples.

E se você desejasse mudar o nome desta mesma planilha. Como faria isto, usando o tal de COM via Python? Simples. Bastaria usar o seguinte script modificado.

01. from win32com import client as win32
02. 
03. excel = win32.Dispatch('Excel.Application')
04. excel.Visible = True
05. wb = excel.Workbooks.Add()
06. wb.Activate()
07. ws = wb.Sheets('Sheet1').Name = "New Name"
08. 
09. while True:
10.     pass

Código em Python

E o resultado é visto na imagem abaixo.

Note que apenas adicionamos uma única linha. Esta foi a linha sete, no script em Python. E o resultado foi exatamente o que esperávamos. Mas ainda não colocamos nenhuma informação na planilha. Como poderíamos fazer isto? Novamente é algo bastante simples e direto. Bataria que apontássemos o local, e colocar a informação ali. Já que esta parte pode depender do que estamos pretendendo fazer. Irei mostrar uma de tantas forma de fazer isto. Mas seria algo do estilo mostrado abaixo.

01. from win32com import client as win32
02. 
03. excel = win32.Dispatch('Excel.Application')
04. excel.Visible = True
05. wb = excel.Workbooks.Add()
06. wb.Activate()
07. wb.Sheets('Sheet1').Name = "New Name"
08. ws = wb.Sheets('New Name')
09. ws.Range('E6').Value = 'Checking.'
10. 
11. while True:
12.     pass

Código em Python

E como resultado, teríamos exatamente o que pode ser visto na imagem abaixo.

Caramba. Que coisa mais maluca. Note que se você colocasse uma fórmula, ela seria calculada. Agora atenção ao seguinte fato. Note que foi adicionada a linha oito e nove. O motivo é que ao adicionar a linha oito, garantimos que não precisaremos ficar repetindo o nome da aba a todo momento. Mas você poderia unir a linha oito e nove em uma única linha.

Mas espera uma pouco. Este código visto neste último script me parece bastante familiar. Bem, se você está pensando isto, não é por qualquer motivo. De fato, uma vez que tenhamos feito a abertura do Excel e o tornado visível. Todo o restante se parece bastante com um código feito em VBA. Esta é a mágica da tal interface COM. Note que estamos criando um script em Python, mas muito do que estamos fazendo se parece bastante com um script em VBA. Este tipo de coisa abre as portas para que possamos fazer muito, mas muito mais do que foi visto até então.

Ok, mas tudo que foi feito aqui, poderia ser feito, usando outros pacotes que eu poderia instalar no python. Sim, isto é verdade meu caro leitor. Porém, fazendo desta forma como acabei de mostrar, você deve ter notado que podemos usar um script que seria usado no VBA, aqui no Python. Beleza, entendi como fazer quando quero abrir uma planilha em branco. Mas e se eu já estiver com o Excel aberto, como poderia fazer este mesmo tipo de coisa? Neste caso, meu caro leitor, a coisa seria muito mais simples e direta. Isto por que tudo que seria preciso fazer, seria acessar o Excel e dizer onde fazer as mudanças. Então o código ficaria como mostrado abaixo:

1. from win32com import client as win32
2. 
3. excel = win32.GetActiveObject('Excel.Application')
4. excel.Worksheets('Sheet1').Range('D5').Value = "Cool..."

Código em Python

E o resultado da execução deste script, pode ser visto logo abaixo.

Veja que é muito mais direto e muito mais fácil do que pode parecer a primeira vista. Observe, que na linha três, pedimos para que a interface, nos dê o objeto para manipular a aplicação. Esta no caso, é o Excel. Já na linha quatro, dizemos quem e onde faremos a manipulação. Simples assim. Porém tudo isto que foi visto até aqui é o básico do básico. O que foi visto, visa mostrar a você, caro leitor, que não é preciso baixar e instalar um monte de pacotes no Python. Tudo que você precisa realmente saber, e como usar o que já vem por padrão no Python. Além é claro, ter que estudar um pouco mais sobre alguma técnica e tecnologias que já existem a anos.

Ok. Esta foi a parte básica do que precisamos para que nosso servidor venha a funcionar. Isto de maneira que ele não interfira no uso normal do Excel por parte de algum usuário. A próxima coisa que você, caro leitor, precisa entender, é como manipular algumas coisas no Excel. E não estou dizendo, em termos de fórmulas ou coisas do tipo. Quero que você entenda, que podemos fazer uso desta tecnológica COM, para ir muito além do que normalmente vemos as pessoas fazerem no Python. Mas para separar as coisas e você compreender melhor o que explicarei. Vamos a um novo tópico.

Eventos e mais eventos

Grande parte dos usuários, não tem a mínima noção de que vários programas, são na verdade, sistemas de respostas a eventos. Estes eventos podem ser de qualquer natureza. Seja um clique. Seja um digitar de texto, ou seja, algo envolvendo comunicação entre processos ou programas. Quando a ideia é sistema operacional multi tarefas, a principal coisa são os eventos.

E aqui, não é diferente. Se bem, que a princípio não precisamos de muitas coisas. No entanto, para que nosso servidor, escrito em Python, possa interagir com o Excel. E fazer isto sem ficar competindo com o Excel no que rege o uso da CPU. Precisamos entender como fazer com que o Python, observe os eventos que estão ocorrendo no Excel. Para ser sincero, precisamos que o nosso servidor, saiba o que o Excel está fazendo. Isto para que ele saiba, quando ser encerrado, ou acionado.

Não se esqueça. A ideia é manter o Excel aberto, recebendo dados em tempo real do MetaTrader 5. Isto poderia ser feito via RTD ou DDE. Mas queremos também que o Excel envie comandos para o MetaTrader 5. Isto para que apenas observando o Excel, um operador possa dar ordens ao MetaTrader 5. E ao fazer isto, o MetaTrader 5, fará com que algum Expert Advisor consiga entender tais ordens criadas lá no Excel. Assim o Expert Advisor poderá executar as operações que o operador requisitou. E tudo isto, sem que o operador de fato, tenha na sua tela o MetaTrader 5, ou ativo. Ele apenas observará o Excel e com base em algum tipo de análise, seja fundamentalista, ou outra qualquer. Ele, operador, poderá comprar ou vender qualquer ativo diretamente pelo Excel. Ignorando completamente o gráfico.

Muito bem, mas como podemos fazer com que um script que foi feito no Python, consiga saber o que, um usuário no Excel está fazendo? Lembrando que estou usando o Excel como exemplo. Mas o que irei explicar, funciona para qualquer programa que use a tecnologia COM.

A forma de fazer isto é simples. Porém, é preciso que você entenda como o programa a ser observado funciona. Para isto, nas referências, você terá acesso ao material necessário para fazer outras coisas relacionadas ao que mostrarei. E não seja preguiçoso, estude o material antes de perguntar como faz isto, ou como fazer aquilo. Isto por que, se você entender as coisas, poderá fazer bem mais do que simplesmente perguntando e querendo uma resposta já pronta. Estude o material e a documentação do programa que você deseja fazer uso via COM.

Dado este recado, vamos ver como a coisa de fato funciona. Para isto precisaremos modificar um pouco os scripts vistos acima. Porém, para facilitar ao máximo, já que a ideia aqui é ser didático, além de prático. Vamos considerar que o Excel, já estará aberto no momento que o script em Python for posto para funcionar. Com isto, termos bem menos trabalho, além de ficar mais simples entender e explicar o que estará acontecendo no código.

O código script básico, pode ser visto logo abaixo.

01. from win32com import client as win32
02. import pythoncom as pyCOM
03. import time
04. 
05. class AppEvents:
06.     def OnSheetActivate(self, *arg):
07.         print('Tab ' +  str(arg[0].Name) + ' selected...')
08. 
09. class SheetEvent:
10.     def OnSheetSelectionChange(self, *args):
11.         print(args[1].Address)
12.         args[0].Cells(1, 1).Value = "Select " + str(args[1].Address)
13. 
14. excel = win32.GetActiveObject('Excel.Application')
15. 
16. win32.WithEvents(excel, AppEvents)
17. win32.WithEvents(excel.Workbooks('Book1'), SheetEvent)
18. 
19. print("Enter in loop...")
20. while True:
21.     pyCOM.PumpMessages()
22.     print('ping...')
23.     time.sleep(1)

Código em Python

Como resultado da execução você verá duas coisas. A primeira é vista diretamente no Excel, conforma a figura abaixo.

A segunda coisa é vista no terminal onde o script estará sendo executado. No caso estou usando o Visual Code, então na área que replica o que seria visto no prompt, você pode ver os seguintes dados:

Note que isto está replicando, ou melhor dizendo, está mostrando o que foi feito no Excel. Mas como isto é possível? Lembrando que este código é apenas para fins didáticos. Podemos fazer muito mais do que é mostrado aqui. Mas vamos entender o que aconteceu aqui. Assim você poderá, quem sabe fazer algo bastante interessante com este conhecimento.

Antes de começarmos, quero chamar a sua atenção, meu caro leitor, para um detalhe neste código. Irei mostrar em um ponto, mas serve para todos os pontos. Seja algum que você queira criar, seja o outro ponto também presente no script. O ponto em questão é a linha seis. Mas o que irei falar, serve também para a linha dez.

Se você ir na documentação, que estou deixando como referência neste artigo. E procurar os eventos da aplicação do Excel. Irá encontrar o seguinte evento: Application.SheetActivate event. Muito bem, mas por que estou dizendo isto? O motivo é simples. Você NÃO DEVE USAR QUALQUER NOME para se referir a um evento, aqui no script em python. Se você fizer isto o script não funcionará capturando o evento.

Preste atenção a uma coisa no código. Na linha cinco, estou definindo uma classe. Esta classe conterá todos os eventos da aplicação que você queira capturar. Assim como na linha nove, onde também criamos uma outra classe, que tem como finalidade tratar de outro tipo de evento. No caso o evento em questão é os que envolvem a planilha em si. Note que ambos estão separados e tem objetivos diferentes. O nome da classe pode ser qualquer nome válido. Porém o nome do procedimento não segue esta regra. Para que o procedimento seja ligado a um evento, você precisa colocar o nome de uma forma específica.

Agora voltando lá na documentação. Como queremos usar o evento Application.SheetActivate no nosso script em Python. Precisamos fazer o seguinte: O nome do evento a ser capturado, deverá iniciar com On, logo depois vem o nome do evento, que no caso é SheetActivate. Assim temos o nome que o procedimento deverá ter. Uma outra coisa é notar na documentação quantos argumentos, ou parâmetros cada um dos eventos utiliza. Você pode usar a mesma formatação que mostro aqui. Isto para todos os eventos. Assim o Python, converterá os argumentos ou parâmetros reais em uma tupla que você poderá usar dentro do Python. Se você não sabe o que é uma tupla ou como usar uma, procure estudar a documentação do python. Pois isto é o mais básico do básico para quem deseja programar em Python.

Mas voltando ao código, agora já podemos ver como ele funciona. Na imagem do terminal eu removi a linha 22. Isto por que ela estava colocando muitas mensagens, e isto atrapalharia a correta visualização do que havia ocorrido. Mas para efeitos de estudo, aconselho a você no primeiro momento deixar esta linha ativa. Isto para perceber uma coisa. A chamada na linha 21 não bloqueará o código. Ela apenas faz com que as classes que estão ligadas aos eventos, venham a receber os eventos. Ficou confuso? Então vamos esclarecer as coisas.

Observe que a linha 14 temos algo que já vimos antes. Isto tem como objetivo capturar uma sessão do Excel. Ok, o que realmente nos interessa é a variável em si. Observe que ela será usada em dois pontos. O primeiro ponto é na linha 16. Nesta linha dizemos qual será a classe que tratará dos eventos ligados a aplicação. O segundo parâmetro desta chamada representa o nome da classe. Já o segundo ponto onde usamos a variável é na linha 17. Agora atenção. Observe que estamos usando uma ligação específica. No caso esta ligação estará se referindo ao nome do arquivo aberto no Excel. Caso você esteja usando um arquivo com um nome diferente, troque o mesmo neste ponto. Isto para que o sistema consiga capturar corretamente os eventos. E igual ao que foi feito antes, o segundo parâmetro se refere ao nome da classe que irá tratar os eventos que ocorrerem em uma aba.

Irei deixar como curiosidade, para você caro leitor. Experimentar, e procurar entender, o que está acontecendo e por que da forma como este script está escrito. Conseguimos reportar no nome da aba e as células selecionadas em cada uma das abas. Acredito que se você procurar de fato entender o que está acontecendo, irá ficar bastante interessado em tornar este script ainda melhor.

Considerações finais

Neste artigo, apresentei de forma que fosse o mais simples possível, algo que muitos desconhecem. Ou seja, como o python consegue manipular informações e acessar programas via interface COM. Espero que este material venha a despertar em você, caro leitor e aspirante a programador profissional, um maior interesse em aprender como as coisas realmente funcionam. Tudo o que foi visto e mostrado aqui, é a parte mais básica de tudo que realmente podemos fazer. Muitos acreditam que precisamos instalar diversas coisas e fazer um verdadeiro malabarismo em termos de programação. Mas na verdade, entender e conhecer o que já existe em termos de tecnologia, já será mais do que o suficiente para produzir muita coisa e de boa qualidade.

Apesar de não ter mostrado como tudo isto irá se ligar a ponto de fazer com que o Python, mantenha um servidor ativo. E este mesmo servidor consiga manipular, escrever e ler dados em uma planilha sem afetar em nada o funcionamento do Excel. Acredito que aqueles com mais visão e experiência em programação, já tenham imaginado como tudo irá se ligar. Mas se este não é o seu caso, ainda meu caro leitor. Não se preocupe. No próximo artigo veremos como iremos fazer esta implementação. Então até o próximo artigo. E não se esqueça de começar a estudar o material que se encontra na área de referência do artigo, pois isto lhe será de grande valia, se seu desejo é se tornar um programador de qualidade e profissional.

Referências:

• COM (Componet Object Model )
• Office VBA Reference
• Python for Win32 Extensions Help

Arquivo	Descrição
Experts\Expert Advisor.mq5	Demonstra a interação entre o Chart Trade e o Expert Advisor (É necessário o Mouse Study para interação)
Indicators\Chart Trade.mq5	Cria a janela para configuração da ordem a ser enviada (É necessário o Mouse Study para interação)
Indicators\Market Replay.mq5	Cria os controles para interação com o serviço de replay/simulador (É necessário o Mouse Study para interação)
Indicators\Mouse Study.mq5	Permite interação entre os controles gráficos e o usuário (Necessário tanto para operar o replay simulador, quanto no mercado real)
Services\Market Replay.mq5	Cria e mantém o serviço de replay e simulação de mercado (Arquivo principal de todo o sistema)
Code VS C++\Servidor.cpp	Cria e mantém um soquete servidor criado em C++ (Versão Mini Chat)
Code in Python\Server.py	Cria e mantém um soquete em python para comunicação entre o MetaTrader 5 e o Excel
Scripts\CheckSocket.mq5	Permite efetuar um teste de conexão com um soquete externo
Indicators\Mini Chat.mq5	Permite implementar um mini chat via indicador (Necessário uso de um servidor para funcionar)
Experts\Mini Chat.mq5	Permite implementar um mini chat via Expert Advisor (Necessário uso de um servidor para funcionar)