Développer un Expert Advisor à partir de zéro (partie 15) : Accéder aux données du web (I)

Introduction

MetaTrader 5 est la plateforme la plus polyvalente et la plus complète qu'un trader puisse désirer. Malgré ce qu’il peut être dit, la plateforme est extrêmement efficace et puissante. Elle offre des possibilités qui vont bien au-delà de la simple observation d'un graphique tracé, avec des opérations d'achat et de vente en temps réel.

Toute cette puissance vient du fait que la plateforme utilise un langage qui est presque égal au plus puissant langage existant actuellement : le C/C++. Les possibilités que ce langage nous offre vont bien au-delà de ce que les traders ordinaires, sans compétences en programmation, sont capables de réaliser ou de comprendre.

Pendant les opérations sur le marché, nous devons être connectés d'une manière ou d'une autre aux différentes questions qui se posent au niveau mondial. Nous ne pouvons pas nous contenter du graphique. Il est important de prendre en compte d'autres informations connexes qui ne sont pas moins pertinentes et qui peuvent être un facteur décisif et faire la différence entre une position gagnante et une position perdante.

Il existe un grand nombre de sites et d'endroits sur le web qui contiennent une grande quantité d'informations. Ce que vous devez savoir, c'est où chercher et comment utiliser au mieux ces informations. Et plus vous êtes informé pendant la bonne période, mieux c'est pour votre trading. Cependant, si vous utilisez un navigateur, quel qu'il soit, vous constaterez qu'il est très difficile de bien filtrer les informations, que vous êtes obligé de regarder de nombreux écrans et qu'au final, bien que l'information soit là, il est impossible de l'utiliser.

Mais grâce au MQL5, qui est très proche du C/C++, les programmeurs peuvent faire plus que travailler avec un graphique tel quel : nous pouvons rechercher, filtrer, analyser des données sur le web et ainsi effectuer des opérations de manière beaucoup plus cohérente, que la plupart des traders car nous allons utiliser toute la puissance de calcul en notre faveur.

1. Planification

La partie planification est très importante. Tout d'abord, il est nécessaire de trouver où vous pouvez obtenir les informations que vous voulez utiliser. C’est un point très important car une bonne source d'information nous mettra sur la bonne voie. Tout le monde doit faire cette étape dans son coin, car chaque trader peut avoir besoin de certaines données spécifiques à des moments différents.

Indépendamment de la source que vous choisissez, ce que nous allons faire ensuite sera fondamentalement le même pour tout le monde. Cet article peut donc servir de matériel d'étude pour ceux qui souhaitent utiliser la méthode et les outils disponibles en utilisant uniquement le langage MQL5, sans aucun programme externe.

Pour illustrer l'ensemble du processus, nous allons utiliser une page web donnant des informations sur le marché. Nous passerons en revue toutes les étapes du processus. Vous pourrez utiliser cette méthode en l'adaptant à vos besoins spécifiques.

2. Développer un programme pour capturer les données

Pour commencer à travailler avec les données, nous devons créer un petit programme qui collectera les données et être capable de les analyser de manière efficace et précise. Pour ce faire, nous utiliserons un programme très simple, présenté ci-dessous :

#property copyright "Daniel Jose"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnStart()
{
        Print(GetDataURL("https://tradingeconomics.com/stocks"));
}
//+------------------------------------------------------------------+
string GetDataURL(const string url, const int timeout = 750)
{
	string headers;
	char   post[], charResultPage[];
	int    handle;
   
	if (WebRequest("GET", url, NULL, NULL, timeout, post, 0, charResultPage, headers) == -1) 
		return "Bad return";
	if ((handle = FileOpen("url.txt", FILE_WRITE | FILE_BIN)) != INVALID_HANDLE) 
        { 
                FileWriteArray(handle, charResultPage, 0, ArraySize(charResultPage)); 
                FileClose(handle); 
        }else
                return "Error saving file ...";
                
	return "File saved successfully...";
}

Ce programme est extrêmement simple.

Nous procédons de la façon suivante : dans la partie en surbrillance, nous indiquons le site à partir duquel nous voulons recevoir des informations. Pourquoi utilisons-nous ce programme et pas le navigateur ? Il est vrai que nous pouvons capturer des informations dans le navigateur. Mais nous l'utiliserons pour aider à trouver des informations après avoir téléchargé les données.

Il ne faut pas que vous tapiez simplement et que vous compiliez ce programme. Il y a autre chose que vous devez faire, sinon ça ne marchera pas.

Dans la plateforme MetaTrader, nous devons autoriser la plateforme à recevoir des données du site souhaité avant d'exécuter ce script. Pour éviter de le faire à chaque fois que vous devez installer la plateforme MetaTrader, vous pouvez sauvegarder une copie de ces données une fois que tout est configuré. Le fichier doit être enregistré dans l’emplacement suivant :

C:\Users\< USER NAME >\AppData\Roaming\MetaQuotes\Terminal\< CODE PERSONAL >\config\common.ini

USER NAME est votre nom d'utilisateur dans le système d'exploitation. CODE PERSONAL est la valeur de votre code personnel que la plateforme a créé lors de l'installation. Vous pouvez ainsi facilement trouver le fichier pour faire une sauvegarde ou pour le remplacer après une nouvelle installation. Juste un point : ce chemin correspond à un système WINDOWS.

Revenons maintenant au script que nous avons créé. Si vous l'utilisez sans configuration préalable, vous verrez apparaître la fenêtre suivante :

Ce message est affiché car nous n'avons pas autorisé le site web dans la plateforme MetaTrader. Il faut le faire comme indiqué dans la figure ci-dessous. Faites bien attention à ce qui a été ajouté. Notez qu'il s'agit de l'adresse racine du site à laquelle nous allons accéder via la plateforme de trading MetaTrader.

          

Si nous exécutons maintenant à nouveau le même script, nous verrons la sortie suivante rapportée par la plateforme :

Cela signifie que le site a été consulté avec succès, que les données ont été téléchargées sur votre ordinateur et que vous pouvez maintenant les analyser. Un détail important est que maintenant nous n'avons plus à nous soucier d'ajouter à nouveau le même site à la plateforme, à condition bien sûr de créer une sauvegarde du fichier indiqué ci-dessus.

Pour comprendre comment tout va fonctionner ici et pour obtenir des informations plus détaillées, vous pouvez consulter la fonction WebRequest dans la documentation. Si vous souhaitez en savoir plus sur le protocole de communication réseau, je vous recommande de jeter un coup d'œil aux autres fonctions réseau, présentées dans MQL5. La connaissance de ces fonctions peut parfois vous éviter bien des soucis.

Nous avons terminé la première partie du travail : nous sommes arrivés à télécharger les données du site souhaité. Nous devons maintenant passer à l'étape suivante, qui est toute aussi importante.

3. Recherche des données

Pour ceux qui ne savent pas comment rechercher les données à capturer par la plateforme MetaTrader 5 au sein d'un site web, j'ai réalisé une courte vidéo, où je montre rapidement comment faire cette recherche.

Il est important que vous sachiez comment utiliser votre navigateur pour analyser le code du site web dont vous voulez obtenir les données. Ce n'est pas difficile, car le navigateur lui-même aide beaucoup dans cette tâche. Mais c'est quelque chose que vous devez apprendre à réaliser. Une fois que vous aurez compris comment faire, de nombreuses possibilités s'offriront à vous.

J'utiliserai Chrome pour la recherche. Mais vous pouvez utiliser tout autre navigateur qui permet d'accéder au code à l'aide des outils de développement.

Une fois que vous avez appris ce qu'il faut chercher, où le chercher et comment accéder aux informations que vous voulez, ouvrez le fichier que vous avez téléchargé sur le site, en utilisant la plateforme MetaTrader et commencez à chercher les données dont vous avez besoin.

Ce qui nous intéresse, c'est d'obtenir les données du bloc ci-dessous, celui que je cherchais dans la vidéo ci-dessus. Il est vraiment important de savoir comment rechercher des choses à l'aide du navigateur, sinon vous serez perdu dans toutes ces informations téléchargées.

Fans certains cas, le simple fait d'examiner les données de cette manière peut malheureusement ne pas suffire. Nous devons recourir à un éditeur hexadécimal pour savoir exactement à quoi nous avons affaire. Il est vrai que dans certains cas, la modélisation des données est relativement simple. Mais dans d'autres cas, cela peut être beaucoup plus complexe, lorsque les données contiennent des images, des liens et d'autres éléments par exemple. Ces éléments peuvent compliquer les recherches, car ils donnent généralement des faux positifs. Il faut donc se méfier. En recherchant les mêmes données dans un éditeur hexagonal, nous obtenons les valeurs suivantes :

Nous ne sommes pas intéressés par les décalages à cette première étape car ils peuvent changer dans le cas de pages dynamiques. Mais nous sommes intéressés de voir quel type de modélisation est utilisé. Dans ce cas, c'est très clair. Nous pouvons utiliser un système de recherche basé sur ce type d'information trouvé ici dans l'éditeur hexadécimal. Cela rend la recherche par notre programme légèrement plus simple à mettre en œuvre, même si ce n'est pas encore un système efficace. Notre base de données de recherche est plus facile d'accès : nous utiliserons des entrées et n'utiliserons pas de caractères supplémentaires, tels que CARRIAGE ou RETURN, qui nous gênent plus qu'ils ne nous aident. Ainsi, le code du programme est le suivant :

#property copyright "Daniel Jose"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnStart()
{
        while (!IsStopped())
        {
                Print(GetDataURL("https://tradingeconomics.com/stocks"));
                Sleep(200);
        }
}
//+------------------------------------------------------------------+
string GetDataURL(const string url, const int timeout = 100)
{
        string  headers, szInfo;
        char    post[], charResultPage[];
        int     handle;
   
        if (WebRequest("GET", url, NULL, NULL, timeout, post, 0, charResultPage, headers) == -1)
                return "Bad return";
   
        szInfo = "";
        for (int c0 = 0, c1 = ArraySize(charResultPage); c0 < c1; c0++) szInfo += CharToString(charResultPage[c0]);
        if ((handle = StringFind(szInfo, "data-symbol=\"INDU:IND\"", 0)) >= 0)
        {
                handle = StringFind(szInfo, "<td id=\"p\" class=\"datatable-item\">", handle);
                for(; charResultPage[handle] != 0x0A; handle++);
                for(handle++; charResultPage[handle] != 0x0A; handle++);
                szInfo = "";
                for(handle++; charResultPage[handle] == 0x20; handle++);
                for(; (charResultPage[handle] != 0x0D) && (charResultPage[handle] != 0x20); handle++) szInfo += CharToString(charResultPage[handle]);
        }
        return szInfo;
}

L'idée du script est de capturer une valeur sur la page. L'avantage de la méthode présentée ci-dessus est que même si l'information change de position en raison d'un décalage, nous pouvons toujours la retrouver parmi toutes ces commandes. Mais même si tout semble idéal, il y a un petit retard dans l'information. Il est donc nécessaire de mesurer comment vous allez travailler avec les données capturées, lorsque le script ci-dessus est exécuté. Voici le résultat de l'exécution :

Je vous conseille de mener votre propre analyse et de voir comment les informations sont enregistrées. Il est important de connaître les détails qui ne sont pas si faciles à décrire sous forme de texte : il faut les voir pour comprendre.

Réfléchissons maintenant à ce qui suit : le script ci-dessus n'est pas très efficace en termes d'exécution car il effectue certaines manipulations qui ne sont pas nécessaires lorsqu'on utilise une page statique. Mais il est utilisé avec un contenu dynamique, comme dans le cas de la page que nous examinons. Dans ce cas particulier, nous pouvons utiliser le décalage pour analyser plus rapidement et donc saisir les données plus efficacement. Mais n'oubliez pas que le système peut conserver les informations dans un cache pendant quelques secondes. Les informations capturées peuvent être donc obsolètes par rapport aux données observées dans le navigateur. Dans ce cas, il est nécessaire d'effectuer quelques ajustements internes au système pour y remédier. Mais ce n'est pas l'objet de cet article.

Ainsi, en modifiant le script ci-dessus pour utiliser un décalage lors de la recherche, nous obtenons le code suivant :

#property copyright "Daniel Jose"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnStart()
{
        while (!IsStopped())
        {
                Print(GetDataURL("https://tradingeconomics.com/stocks", 100, "INDU:IND", 172783, 173474, 0x0D));
                Sleep(200);
        }
}
//+------------------------------------------------------------------+
string GetDataURL(const string url, const int timeout, const string szFind, int iPos, int iInfo, char cLimit)
{
        string  headers, szInfo = "";
        char    post[], charResultPage[];
        int     counter;
   
        if (WebRequest("GET", url, NULL, NULL, timeout, post, 0, charResultPage, headers) == -1)
	        return "Bad return";

        for (int c0 = 0, c1 = StringLen(szFind); c0 < c1; c0++) if (szFind[c0] != charResultPage[iPos + c0]) return "Error in Position";
        for (counter = 0; charResultPage[counter + iInfo] == 0x20; counter++);
        for (;charResultPage[counter + iInfo] != cLimit; counter++) szInfo += CharToString(charResultPage[counter + iInfo]);
        
        return szInfo;
}

Le résultat de l'exécution du script peut être vu plus loin. Il n'y a pas de gros changement. Ce n’est qu’une question de temps de calcul qui est réduit avec le modèle de décalage. Tout cela améliore légèrement les performances globales du système.

Veuillez noter que le code ci-dessus ne fonctionnait que parce que la page était statique : nous pouvons donc utiliser un éditeur hexadécimal, rechercher l'emplacement des informations, obtenir les valeurs de décalage et naviguer immédiatement vers ces positions. Mais pour avoir une certaine garantie que les décalages sont toujours valides, nous faisons un test simple :

for (int c0 = 0, c1 = StringLen(szFind); c0 < c1; c0++) if (szFind[c0] != charResultPage[iPos + c0]) return "Error in Position";

C'est quelque chose de très simple, mais qui est nécessaire pour que nous ayons un minimum de sécurité concernant les informations qui sont capturées avec le décalage. Pour cela, nous devons analyser la page et vérifier s'il est possible d'utiliser la méthode de décalage pour capturer les données. Si cela est possible, vous bénéficierez d'un délai de traitement plus court.

4. Un problème à résoudre

Bien que le système fonctionne souvent très bien, il peut arriver que nous recevions une erreur du serveur :

C'est l’erreur correspondant à la réponse du serveur à notre demande. Même si WebRequest n'indique aucune erreur du côté de la plateforme, le serveur peut renvoyer ce message. Dans ce cas, nous devons analyser l'en-tête du message de retour pour comprendre le problème. Pour résoudre ce problème, il est nécessaire d'apporter de petites modifications au script de décalage, que l'on peut voir ci-dessous :

#property copyright "Daniel Jose"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnStart()
{
        while (!IsStopped())
        {
                Print(GetDataURL("https://tradingeconomics.com/stocks", 100, "<!doctype html>", 2, "INDU:IND", 172783, 173474, 0x0D));
                Sleep(200);
        }
}
//+------------------------------------------------------------------+
string GetDataURL(const string url, const int timeout, const string szTest, int iTest, const string szFind, int iPos, int iInfo, char cLimit)
{
        string  headers, szInfo = "";
        char    post[], charResultPage[];
        int     counter;
   
        if (WebRequest("GET", url, NULL, NULL, timeout, post, 0, charResultPage, headers) == -1
                return "Bad";
        for (int c0 = 0, c1 = StringLen(szTest); c0 < c1; c0++) if (szTest[c0] != charResultPage[iTest + c0])
                return "Failed";
        for (int c0 = 0, c1 = StringLen(szFind); c0 < c1; c0++) if (szFind[c0] != charResultPage[iPos + c0])
                return "Error";
        for (counter = 0; charResultPage[counter + iInfo] == 0x20; counter++);
        for (;charResultPage[counter + iInfo] != cLimit; counter++) szInfo += CharToString(charResultPage[counter + iInfo]);
        
        return szInfo;

La ligne mise en évidence est celle qui effectue le test. Lorsque le message renvoyé par le serveur est plus complexe, le simple fait d'effectuer ce test nous garantit déjà une bonne marge de sécurité sur les données que nous analysons, en évitant l'analyse de données fantômes ou de déchets de mémoire, si le système passe le premier test qui existait déjà dans le code précédent. Bien que cela se produise rarement, nous ne devons pas sous-estimer la probabilité que cela arrive.

Vous pouvez voir ci-dessous que le résultat n'est pas différent, ce qui signifie que le système fonctionne comme prévu.

Jusqu'à présent, nous n'avons pas fait grand-chose : nous nous contentons de lire les valeurs d'une page web. Cela ne sert pas à grand-chose, même si c'est assez intéressant de savoir et de voir comment cela se passe. Cependant, ce n'est pas très utile pour ceux qui veulent réellement trader sur la base des informations, que vous modéliserez, puisque vous les capturerez et les montrerez d'une autre manière. Nous devons donc agir de manière à ce que cela ait un sens dans un système plus large. Nous allons intégrer ces informations capturées dans un EA. De cette façon nous serons en mesure de faire des choses encore plus impressionnantes et cela fait de MetaTrader 5 une plateforme sensationnelle.

Conclusion

Ce n'est pas encore la fin. Dans le prochain article, je vous montrerai comment intégrer les informations collectées sur le web dans l'EA. Ce sera vraiment impressionnant : nous devrons utiliser des ressources très peu explorées au sein de la plateforme MetaTrader. Ne manquez donc pas le prochain article de cette série.

Tous les codes utilisés dans l'article sont attachés ci-dessous.