Developing an MQL5 RL agent with RestAPI integration (Part 2): MQL5 functions for HTTP interaction with the tic-tac-toe game REST API

Einführung

Im vorangegangenen Artikel haben wir über APIs und RestAPIs gesprochen und aufgezeigt, wie diese wichtigen Technologien die Kommunikation und den Datenaustausch zwischen verschiedenen Systemen erleichtern. Wir haben die Entwicklung von RestAPIs aus der Perspektive der Prinzipien von Roy Fielding analysiert und wie sie ältere Protokolle wie SOAP durch effizientere und flexiblere Alternativen ersetzt haben. Wir betonten auch die Bedeutung der Einfachheit, Skalierbarkeit und Vielseitigkeit von RestAPI sowie ihre Rolle bei der Entwicklung fortgeschrittener vernetzter Systeme.

In diesem neuen Artikel werden wir diese Konzepte vertiefen und auf ein praktisches Beispiel anwenden. Wir werden uns auf die Entwicklung einer Reihe von Funktionen in MQL5 für die Arbeit mit HTTP-Aufrufen und die Integration mit RestAPI-Funktionen für eine effektive Interaktion mit der externen Umgebung konzentrieren. Als praktisches Beispiel betrachten wir die Erstellung des Tic-Tac-Toe-Spiels in Python.

Wir werden mit der Entwicklung von Funktionen in MQL5 beginnen. Diese Funktionen sind notwendig, um eine effektive Kommunikation mit der externen Umgebung herzustellen, in diesem Fall mit dem in Python entwickelten Tic-Tac-Toe-Spiel. Sie ermöglichen das Senden von HTTP-Anfragen und das Empfangen von Antworten und dienen als Kommunikationsbrücke zwischen MQL5 und der Spiel-API.

Parallel dazu werden wir uns die API-Entwicklung mit FastAPI ansehen, das aufgrund seiner Eigenschaften wie hohe Leistung, einfache Entwicklung und starke Unterstützung für asynchrone APIs ausgewählt wurde. FastAPI lässt sich auch gut in moderne API-Entwicklungstools integrieren, was die Erstellung effizienter und skalierbarer Endpunkte erleichtert, die unser MQL5-Feature-Set zur Interaktion mit Tic-Tac-Toe-Spielen nutzen kann.

Nach dem Erlernen der grundlegenden MQL5-Funktionen werden wir ein Testskript erstellen, das mit der Python-API interagiert. Dieses Skript wird das wichtigste Element sein, um die praktische Anwendbarkeit unserer MQL5-Funktionen im Zusammenhang mit dem Tic-Tac-Toe-Spiel zu demonstrieren.

Dieses Beispiel wird nicht nur die praktische Anwendung der oben erörterten Konzepte veranschaulichen, sondern auch einen wertvollen Einblick geben, wie diese Technologien zusammen eingesetzt werden können, um innovative Lösungen zu schaffen.

In diesem Artikel werden wir sowohl die technische Entwicklung von Funktionen in MQL5 als auch die API in FastAPI und ihre Rolle bei der Erstellung von vernetzten Systemen betrachten.

Dieser Artikel ist in vier Hauptteile gegliedert:

1. Einführung und Kontextualisierung. Wir werden kurz die im vorherigen Artikel besprochenen API- und RestAPI-Konzepte besprechen und die Entwicklung und Bedeutung dieser Technologien für die Verbindung von Systemen hervorheben.

2. Entwicklung von Funktionen in MQL5 für HTTP-Aufrufe. Hier werden wir uns auf die Entwicklung spezifischer Funktionen in MQL5 konzentrieren. Diese Funktionen dienen dem Aufbau und der Verwaltung der HTTP-Kommunikation, die ein grundlegender Schritt bei der Integration von MQL5 in externe Umgebungen ist.

3. Erstellung und Integration von API in FastAPI für Tic-Tac-Toe. In diesem Abschnitt werden wir uns mit der Entwicklung einer zuverlässigen API mit FastAPI beschäftigen. Die API dient als Grundlage für unser praktisches Beispiel - Tic-Tac-Toe in Python - und wird mit den in MQL5 entwickelten Funktionen integriert.

4. Praktische Anwendung und Prüfung. Im letzten Teil werden wir ein Testskript in MQL5 für die Interaktion mit der Tic-Tac-Toe-API implementieren. In diesem Schritt werden wir die praktische Integration der besprochenen Werkzeuge und Konzepte demonstrieren und zeigen, wie die folgende Funktion in einem realen Kontext angewendet werden kann:

       def make_move(self, row, col):
           if self.board[row][col] == ' ':
               if self.player_turn:
                   self.board[row][col] = 'X'
               else:
                   self.board[row][col] = 'O'
               self.player_turn = not self.player_turn
           else:
               print("Invalid game. Try again.")
   
   

Jeder dieser Teile trägt zu einem gründlichen Verständnis dafür bei, wie RestAPI und MQL5 zusammen verwendet werden können, um vernetzte Lösungen zu entwickeln.

Das obige Diagramm veranschaulicht die Abfolge der Interaktionen zwischen dem MQL5-Skript und Tic-Tac-Toe, wobei die externe API als Vermittler fungiert. Wir beginnen mit einer Anfrage zum Starten eines Spiels von einem MQL5-Skript, das von einer externen API verarbeitet wird. Dies wiederum ruft das in Python implementierte Tic-Tac-Toe auf. Spielzüge werden über HTTP-Anfragen gesendet und empfangen, und eine externe API verwaltet die Eingabe- und Ausgabelogik. Die Verwendung von FastAPI ist der Schlüssel zur Effizienz dieses Prozesses und gewährleistet asynchrone und leistungsstarke Interaktionen. Dieser Fluss bietet eine visuelle Darstellung der Praktikabilität und Wirksamkeit unseres Ansatzes zur Integration verschiedener Systeme.

1. Einführung und Kontextualisierung

Der heutige Artikel setzt unsere Reihe fort und befasst sich erneut mit der Diskussion über APIs und RestAPIs, wobei der Schwerpunkt auf ihrer Entwicklung und ihrer wachsenden Bedeutung für die Verbindung digitaler Systeme liegt. APIs, die im Zeitalter der Digitalisierung von grundlegender Bedeutung sind, spielen eine entscheidende Rolle bei der Integration verschiedener Programme und gewährleisten die Kommunikation und ein harmonisches Funktionieren. Mit einer Architektur, die auf Einfachheit und Skalierbarkeit ausgerichtet ist, stellt das Aufkommen von RestAPIs einen bedeutenden Fortschritt dar, der die Einschränkungen älterer Protokolle wie SOAP überwindet und eine effizientere Option für die Interoperabilität zwischen Systemen bietet. Der erste Artikel ist der Vertiefung des Verständnisses dieser Schnittstellen gewidmet und beschreibt ihre Funktionalität, Vielfalt und grundlegende Architektur sowie Beispiele für die praktische Anwendung. Wir schaffen die Voraussetzungen für komplexere Diskussionen und spezifischere Anwendungen in zukünftigen Artikeln.

RestAPIs, die um die Jahrtausendwende aufkamen, gewannen schnell an Popularität, da sie im Vergleich zu Protokollen wie SOAP, die auf XML basieren und dafür bekannt sind, komplex zu sein und große Datenmengen für grundlegende Operationen zu benötigen, einen vereinfachten Ansatz bieten. Als flexiblere und vielseitigere Alternative haben sich RestAPIs in verschiedenen Sektoren, einschließlich des Finanzsektors, etabliert. Ihre einfache Verwendung und Implementierung in praktisch allen Programmiersprachen macht sie besonders attraktiv für moderne Systeme, die eine effiziente Kommunikation erfordern.

Die breite Akzeptanz von RestAPIs ist vor allem auf ihre Anpassungsfähigkeit und die Unterstützung verschiedener Datenformate (wie JSON und XML) zurückzuführen, was die Interoperabilität zwischen verschiedenen Systemen und Plattformen erleichtert. Ein wichtiger Aspekt von RestAPI ist außerdem die Sicherheit: Starke Mechanismen wie Token-Authentifizierung und Kryptographie sorgen dafür, dass sensible Informationen beim Datenaustausch geschützt sind. Dieses Maß an Sicherheit und Flexibilität ist vor allem bei Anwendungen wichtig, die kritische Informationen wie Finanztransaktionen und persönliche Daten verarbeiten.

2 - Entwicklung von Funktionen in MQL5 für HTTP-Aufrufe

In diesem Artikel beginnen wir mit einer detaillierten Studie über die Entwicklung von Funktionen in MQL5, um HTTP-Aufrufe zu tätigen und JSON-Daten zu manipulieren. Diese Funktionen spielen eine wichtige Rolle bei der Integration von MQL5-Programmen in die externe Umgebung. Sie ermöglichen eine effektive Interaktion mit Webdiensten und die Bearbeitung von Informationen im JSON-Format.

Außerdem ist es bei der Arbeit mit HTTP-Aufrufen sehr wichtig, die Bedeutung der HTTP-Statuscodes zu verstehen. Diese Codes werden von Webservern zurückgegeben, um das Ergebnis einer Anfrage anzuzeigen. Ein Statuscode „200 OK“ bedeutet zum Beispiel, dass die Anfrage erfolgreich war, während ein Statuscode „404 Not Found“ bedeutet, dass die angeforderte Ressource auf dem Server nicht gefunden wurde. Die Kenntnis dieser Codes ist für die Entwicklung von Anwendungen, die mit Webdiensten interagieren, unerlässlich, da sie wichtige Informationen über den Status einer HTTP-Anfrage liefern.

Vollständige und detaillierte Informationen über HTTP-Statuscodes finden Sie in der vollständigen Dokumentation. So können Sie diese Codes noch besser verstehen und sie in Ihren Projekten sicher einsetzen.

SendGetRequest-Funktion - Ausführen von GET-Anfragen

Wir beginnen mit der Funktion SendGetRequest, die ein zentraler Bestandteil dieses Prozesses ist. Diese Funktion ermöglicht die Implementierung von HTTP-GET-Anfragen. Es akzeptiert eine Reihe von wichtigen Parametern, die ein hohes Maß an Flexibilität und Kontrolle über die Anwendung bieten.

int SendGetRequest(const string url, const string query_param, string &out, string headers = "", const int timeout = 5000)

• url: Die URL, an die die GET-Anfrage gesendet werden soll.
• query_param: Optionale Abfrageparameter, die der URL hinzugefügt werden können.
• out: Ausgabevariable, in der die Antwort auf die Anfrage gespeichert wird.
• headers: Optionale HTTP-Header, die Sie angeben können.
• timeout: Legt das Zeitlimit für die Anfrage in Millisekunden fest.

Die Funktion SendGetRequest ist der Schlüssel für die Verarbeitung von GET-Anfragen, von der Erstellung der Anfrage bis zur Behandlung von HTTP-Fehlern. Es ist wichtig, darauf hinzuweisen, dass die Funktion zwar eine Fehlerbehandlung enthält, aber in ihrer derzeitigen Form relativ einfach ist. Ich denke, dass sie in Zukunft verbessert werden kann.

Nach einer erfolgreichen Antwort (Antwortcode zwischen 200 und 204) dekodiert die Funktion die Daten in UTF-8 und speichert sie in der Variablen „out“. Diese Funktionalität ist notwendig, um sicherzustellen, dass die gesammelten Daten korrekt verarbeitet und in Ihren Projekten effektiv genutzt werden.

Die Funktion SendPostRequest - Ausführen von POST-Anfragen

Kommen wir nun zur Funktion SendPostRequest, die Daten an externe Webdienste weitergibt, wobei die Nutzdaten oft im JSON-Format vorliegen. Diese Funktion wird beim Erstellen oder Aktualisieren von Ressourcen über die API verwendet.

int SendPostRequest(const string url, const string payload, string &out, string headers = "", const int timeout = 5000)

• url: Die URL, an die die POST-Anfrage gesendet werden soll.
• payload: Nutzdaten, die zusammen mit der Anfrage gesendet werden, oft im JSON-Format.
• out: Ausgabevariable, in der die Antwort auf die Anfrage gespeichert wird.
• headers: Optionale HTTP-Header, die Sie angeben können.
• timeout: Legt das Zeitlimit für die Anfrage in Millisekunden fest.

Die Funktion SendPostRequest vereinfacht die Erstellung einer POST-Anfrage, das Hinzufügen von Kopfzeilen und die Behandlung von HTTP-Fehlern, wobei zu beachten ist, dass die derzeitige Fehlerbehandlung möglicherweise nicht vollständig ist und in Zukunft verbessert werden kann, genau wie bei der Funktion SendGetRequest. Wenn die Antwort erfolgreich ist (Antwortcode 200 bis 204), werden die Daten in UTF-8 dekodiert und in der Variablen „out“ gespeichert.

Anforderungsfunktion - Zentraler Ansatz

Die Anforderungsfunktion dient als zentraler Einstiegspunkt für GET- und POST-Anforderungen und bietet einen bequemen und flexiblen Ansatz.

int Request(string method,
            string &out,
            const string url,
            const string payload = "",
            const string query_param = "",
            string headers = "",
            const int timeout = 5000)

• method: Gibt die zu verwendende HTTP-Methode an: “GET“ oder „POST“.
• url: Die URL, an die die Anfrage gesendet werden soll.
• payload: Nutzdaten, die in der POST-Anfrage gesendet werden (optional).
• query_param: Optionale Abfrageparameter für GET-Anfragen.
• out: Ausgabevariable, in der die Antwort auf die Anfrage gespeichert wird.
• headers: Optionale HTTP-Header, die Sie angeben können.
• timeout: Legt das Zeitlimit für die Anfrage in Millisekunden fest.

Die Request-Funktion fungiert als Abstraktionsschicht, die die Wahl zwischen GET und POST erleichtert, ohne dass man sich um Implementierungsdetails kümmern muss. Dies vereinfacht nicht nur den Code, sondern verbessert auch die Lesbarkeit und macht die Entwicklung für HTTP-Aufrufe effizienter und zugänglicher.

      

Das Ziel dieser Erklärung ist es, dem Leser zu zeigen, wie er effektiv mit HTTP-Aufrufen arbeiten kann. Mit diesem Wissen werden Sie in der Lage sein, Ihre eigenen MQL5-Projekte mit einer breiten Palette von Webdiensten zu integrieren, die es Ihnen ermöglichen, Daten mit den Möglichkeiten von HTTP-Aufrufen zu senden und zu empfangen und effizient mit Daten im JSON-Format zu arbeiten. Wir werden diese Ressourcen weiter erforschen und Sie Schritt für Schritt anleiten, damit Sie Ihre MQL5-Programmierkenntnisse beherrschen und ein Experte für die Interaktion mit Webdiensten über HTTP werden.

Neben der Beherrschung von HTTP-Aufrufen in MQL5 ist es wichtig, das JSON-Format (JavaScript Object Notation) zu verstehen. JSON ist eine effiziente und weit verbreitete Methode zur Strukturierung von Daten, die häufig zum Austausch von Informationen zwischen Systemen verwendet wird. Hier sind nur einige Gründe, warum es wichtig ist, den Umgang mit JSON zu lernen:

1. Standard-Webformat: JSON ist das bevorzugte Format für viele Web-APIs und damit von grundlegender Bedeutung für die Integration von externen Anwendungen und Diensten. Wenn Sie JSON verstehen, können Sie problemlos Daten von Webdiensten in einer Struktur senden und empfangen, die weithin verwendet und verstanden wird.

2. Leichtes Lesen und Schreiben: JSON ist für seine gute Lesbarkeit bekannt. Sie verwendet eine einfache, für den Menschen lesbare Syntax, die es Entwicklern erleichtert, Daten zu verstehen und zu debuggen, was besonders wichtig ist, wenn sie mit API-Antworten arbeiten und Anfragen debuggen.

3. Flexibilität und Verschachtelung: JSON ermöglicht die Verschachtelung von Objekten und Arrays, was ideal für die Darstellung komplexer und hierarchischer Daten ist. Dies ist sehr wichtig, wenn man mit detaillierten und strukturierten Informationen arbeitet.

4. Kompatibel mit verschiedenen Sprachen: JSON ist mit einer breiten Palette von Programmiersprachen kompatibel und daher vielseitig einsetzbar. Unabhängig von der verwendeten Sprache erleichtert das Verständnis von JSON die Arbeit mit Daten.

Bedeutung von JSON für HTTP-Aufrufe

Nachdem wir nun die Bedeutung von JSON verstanden haben, müssen wir sehen, wie es sich in HTTP-Aufrufe integriert. Sowohl für eingehende Anfragen (Senden von Daten) als auch für ausgehende Antworten (Empfangen von Daten) spielt JSON eine grundlegende Rolle.

Wenn Sie Daten an einen Webdienst senden, müssen Sie diese oft als JSON formatieren und in die Anfrage einfügen. Dies ermöglicht es dem Dienst, diese Daten richtig zu verstehen und zu verarbeiten. Andererseits werden beim Empfang von Antworten von Webdiensten die Daten oft im JSON-Format zurückgegeben. Daher ist es wichtig zu wissen, wie man JSON analysiert und Informationen daraus extrahiert.

Um die Arbeit mit JSON in MQL5 weiter zu vereinfachen, habe ich mich für die Verwendung der Bibliothek JAson entschieden, die in nativem MQL5 geschrieben ist. Dadurch entfällt die Notwendigkeit, externe DLLs zu verwenden. Diese Bibliothek ist bemerkenswert einfach zu handhaben und hat ihre Wirksamkeit bewiesen. Lassen Sie uns nun einen genaueren Blick darauf werfen, warum die JAson-Bibliothek eine ausgezeichnete Wahl für die Arbeit mit JSON in unseren MQL5-Projekten ist:

1. Nutzerfreundlichkeit: Einer der Hauptvorteile der JAson-Bibliothek ist ihre Nutzerfreundlichkeit. Es wurde entwickelt, um die Arbeit mit JSON zu vereinfachen, indem es das Lesen, Schreiben und Manipulieren von JSON-Objekten auch für unerfahrene Programmierer zugänglich macht. Intuitive Syntax und durchdachte Funktionalität ermöglichen es Ihnen, bei der Arbeit mit JSON Zeit und Mühe zu sparen.

2. Bequeme Abstraktion: JAson bietet eine bequeme Abstraktion für JSON, was bedeutet, dass wir uns nicht manuell mit den Details des Parsings und der Serialisierung befassen müssen. Stattdessen können wir die von der Bibliothek bereitgestellten Methoden und Funktionen verwenden, um allgemeine Aufgaben wie den Zugriff auf Eigenschaften von JSON-Objekten, das Hinzufügen von Elementen zu JSON-Arrays und die Erstellung komplexer JSON-Strukturen durchzuführen.

3. Die Lesbarkeit des Codes wurde verbessert: Die direkte Arbeit mit JSON in unserem MQL5-Code kann komplex sein und zu verwirrendem Code führen. Durch die Verwendung der JAson-Bibliothek erhalten wir jedoch einen besser lesbaren und organisierten Code. Die mit JSON verbundenen Vorgänge werden vereinfacht, wodurch unser Code verständlicher und wartbarer wird.

4. Effizienz der Entwicklung: Effizienz ist ein wichtiger Punkt bei der Entwicklung eines Projekts. Die JAson-Bibliothek kann dazu beitragen, den Entwicklungsprozess zu beschleunigen, da wir uns auf die Geschäftslogik und nicht auf die detaillierte JSON-Verarbeitung konzentrieren können. Das bedeutet, dass wir Funktionen schneller und mit weniger Fehlern bereitstellen können.

3. Erstellung und Integration einer API in FastAPI für das Spiel Tic-Tac-Toe

Beginnen wir unser praktisches Beispiel mit dem Erlernen des Tic-Tac-Toe-Codes in Python. Dies ist ein grundlegender Schritt in der Entwicklung der Interaktion zwischen MQL5 und Python, da Tic-Tac-Toe als Umgebung dienen wird, mit der MQL5 interagieren wird.

TicTacToe-Klasse:

import random

class TicTacToe:

Hier importieren wir das Modul „random“ und erstellen eine Klasse namens TicTacToe. Eine Klasse ist eine Softwarestruktur, die verwandte Funktionen und Variablen organisiert. In diesem Fall stellt die Klasse TicTacToe das Tic-Tac-Toe-Spiel dar.

Initialisieren Sie das Spielbrett:

    def __init__(self):
        self.board = [[' ' for _ in range(3)] for _ in range(3)]
        self.player_turn = True

In diesem Teil werden wir die Methode __init__ definieren, die eine spezielle Methode ist, die aufgerufen wird, wenn eine Instanz einer Klasse erstellt wird. Sie initialisiert den Spielstand.

• self.board ist eine zweidimensionale Liste (3x3), die das Spielbrett darstellt. Zu Beginn sind alle Zellen leer (dargestellt durch leere Zellen).
• self.player_turn ist eine boolesche Variable, die festhält, wer im Spiel am Zug ist. Zu Beginn ist der erste Spieler an der Reihe (True).

Methode print_board:

    def print_board(self):
        for row in self.board:
            print("|".join(row))
            print("-" * 5)

Die Methode print_board ist für die Anzeige des aktuellen Zustands des Spielbretts zuständig. Es läuft durch die Zeilen des Spielplans und druckt Elemente, die durch vertikale Balken ('|') und horizontale Linien ('-----') getrennt sind, um eine visuelle Darstellung des Spielplans zu erzeugen.

Die Methode check_winner:

    def check_winner(self):
        for i in range(3):
            if self.board[i][0] == self.board[i][1] == self.board[i][2] != ' ':
                return self.board[i][0]
            if self.board[0][i] == self.board[1][i] == self.board[2][i] != ' ':
                return self.board[0][i]
        if self.board[0][0] == self.board[1][1] == self.board[2][2] != ' ':
            return self.board[0][0]
        if self.board[0][2] == self.board[1][1] == self.board[2][0] != ' ':
            return self.board[0][2]
        return None

Die Methode check_winner prüft, ob es einen Gewinner im Spiel gibt. Sie prüft alle Zeilen, Spalten und Diagonalen auf drei aufeinanderfolgende Symbole eines Einzelspielers („X“ oder „O“). Wenn ein Spieler gewinnt, wird das Symbol dieses Spielers zurückgegeben (zum Beispiel „X“, wenn Spieler „X“ gewinnt). Wenn kein Gewinner gefunden wird, gibt die Methode None zurück.

Die Methode make_move:

    def make_move(self, row, col):
        if self.board[row][col] == ' ':
            if self.player_turn:
                self.board[row][col] = 'X'
            else:
                self.board[row][col] = 'O'
            self.player_turn = not self.player_turn
        else:
            print("Invalid game. Try again.")

Die Methode make_move ist für die Ausführung eines Zuges im Spiel verantwortlich. Sie erhält die Zeilen- und Spaltenkoordinaten, in denen der Spieler einen Zug machen will. Bevor sie einen Zug macht, prüft sie, ob das Feld auf dem Spielbrett („ “) leer ist. Ist es leer, wird ein Zug ausgeführt und das Spielersymbol („X“ oder „O“) in das Feld gesetzt. Danach ist der Spieler an der Reihe. Wenn die Zelle nicht leer ist, wird die Meldung „Invalid move“ (ungültiger Zug) angezeigt.

Der obige Code stellt den Prozess der Integration zwischen MQL5 und Python dar. Die Entwicklung von Tic-Tac-Toe in Python ist ein wichtiger Schritt, da es als Umgebung dient, in der unsere Interaktionen stattfinden werden.

Wenn Sie jeden Aspekt dieses Codes untersuchen, können Sie sehen, wie einfach und effizient wir mit Python ein funktionales Spiel erstellen können. Das wahre Potenzial dieses Codes wird sich jedoch zeigen, wenn wir ihn mit MQL5 verbinden, wodurch diese beiden unterschiedlichen Technologien synergetisch zusammenarbeiten können.

Nachdem wir nun mit Tic-Tac-Toe eine solide Grundlage geschaffen haben, sind wir bereit für den nächsten Schritt: die Entwicklung einer Python-API mit FastAPI. Diese API ist das Bindeglied zwischen MQL5 und dem Tic-Tac-Toe-Spiel und ermöglicht es MQL5, Abfragen auszuführen und Antworten zu erhalten, um das Spiel zu spielen. Zusammen mit dem Entwicklungsprozess werden wir die Aspekte dieser Integration sehen.

Nachdem wir nun mit der Klasse TicTacToe und ihrer Funktionsweise vertraut sind, wollen wir uns den obigen FastAPI-API-Code genauer ansehen. Diese API wird für die Interaktion zwischen MQL5 und dem Tic-Tac-Toe-Spiel verwendet, das wir zuvor in Python entwickelt haben. Lassen Sie uns die einzelnen Teile dieses Codes verstehen:

# Import of Libraries
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from tic_tac_toe import TicTacToe

# Instantiate FastAPI
app = FastAPI()

# Running game storage
games = {}

Beginnen wir mit dem Importieren der beiden erforderlichen Bibliotheken: FastAPI und Pydantic. FastAPI ist ein Framework für die schnelle Entwicklung von Webschnittstellen in Python. Pydantic wird zur Definition von Datenmodellen verwendet, die die Struktur der von der API erwarteten Daten beschreiben.

# Defining data models
class GameBoard(BaseModel):
    board: list
    player_turn: str

class PlayerMove(BaseModel):
    row: int
    col: int

Als Nächstes werden wir zwei Datenmodelle mit Pydantic definieren. GameBoard stellt den aktuellen Stand des Spielbretts dar. Es gibt die Liste board zum Speichern der Brettzellen und eine Zeichenkette „player_turn“ zur Angabe des Spielfortschritts. PlayerMove stellt die Bewegung dar, die der Spieler ausführen möchte, und enthält die Zeilen- und Spaltenkoordinaten der Bewegung.

# Definition of API Endpoints

# Endpoint to start a new game
@app.get("/start-game/")
def start_game():
    game_id = len(games) + 1
    game = TicTacToe()
    games[game_id] = game
    return {"game_id": game_id}

# Endpoint to make a play in the game
@app.post("/play/{game_id}/")
def play(game_id: int, move: PlayerMove):
    game = games.get(game_id)
    if not game:
        raise HTTPException(status_code=404, detail="Game not found")

    try:
        game.make_move(move.row, move.col)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

    # Use the print_board method to print the current game do
    game.print_board()

    return {
        "board": game.board,
        "player_turn": game.player_turn,
    }

Die API hat zwei Hauptendpunkte. Mit /start-game/ können Sie eine neue Partie Tic-Tac-Toe beginnen. Es erstellt eine Instanz der Klasse TicTacToe, um ein Spiel zu repräsentieren, und verknüpft sie mit einer eindeutigen ID im Spieleverzeichnis. Die Spiel-ID wird als Antwort zurückgegeben.

Der zweite Endpunkt /play/{game_id}/ ermöglicht es Spielern, Züge in einem bestehenden Spiel zu machen. Als Parameter erhält sie die Spiel-ID und die Spieldaten des Spielers. Die API prüft, ob ein Spiel mit der angegebenen ID im Lexikon der Spiele existiert. Wenn sie nicht existiert, wird der Fehler 404 zurückgegeben. Dann versucht sie, einen Zug im Spiel zu machen und den Zustand des Spielbretts zu aktualisieren. Der aktuelle Zustand des Spielbretts wird als Antwort zurückgegeben.

# Execução da API
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Wir vervollständigen den Code, indem wir die API mit Uvicorn ausführen. Dies ermöglicht anderen Anwendungen den Zugriff auf die API. 

Automatisch generierte API-Dokumentation

FastAPI ist ein modernes und schnelles Framework zur Erstellung von APIs in Python 3.6+, basierend auf den Standards von Python type hints. Seine Einfachheit liegt in seiner Fähigkeit, schnelle, effiziente und zuverlässige Kodierung zu bieten, wobei der Schwerpunkt auf den folgenden Fähigkeiten liegt:

1. Geschwindigkeit und Leistung: FastAPI ist eines der schnellsten Frameworks für Python, das Starlette für das Routing und Uvicorn für die ASGI-Serverausführung verwendet. Dies macht ihn ideal für Anwendungen, die eine hohe Leistung erfordern.

2. Automatische Dokumentationserstellung: Mit FastAPI wird die API-Dokumentation automatisch erstellt und bei Änderungen des Codes auch aktualisiert. Ermöglicht wird dies durch die Verwendung von Typ-Hinweisen aus Python und integrierten Dokumentationssystemen wie Swagger UI und ReDoc.

3. Validierung und Serialisierung von Daten: Mit Pydantic bietet FastAPI ein robustes Datenvalidierungssystem. Anfragen und Antworten werden automatisch validiert und serialisiert, so dass weniger Code erforderlich ist und viele gängige Fallstricke vermieden werden.

4. Nutzerfreundlichkeit: FastAPI wurde so konzipiert, dass es einfach zu bedienen und intuitiv zu erlernen ist. Dies macht es für Entwickler einfacher, effiziente APIs zu erstellen und zu pflegen, mit einer weniger steilen Lernkurve im Vergleich zu anderen Frameworks.

5. Unterstützung für asynchrone Operationen: Mit der eingebauten Unterstützung für asynchrone Operationen ist FastAPI für Anwendungen geeignet, die gleichzeitige Anfragen verarbeiten müssen, wie z. B. Echtzeitdienste.

6. Sicherheit und Authentifizierung: Das Framework bietet auch Tools für die Implementierung von API-Sicherheit, einschließlich Unterstützung für OAuth2 mit JWT-Tokens und anderen Authentifizierungsmethoden.

Die Verwendung von FastAPI zur Erstellung einer API zeigt deutlich die Effizienz und Einfachheit des Programms. Dieser Rahmen bietet eine nahtlose Integration zwischen verschiedenen Technologien, wie MQL5 und Python, und ermöglicht Ihnen die schnelle Entwicklung leistungsstarker Webanwendungen. Mit FastAPI können sich Entwickler mehr auf die Geschäftslogik und weniger auf die technischen Details der API-Implementierung konzentrieren, was den Entwicklungsprozess beschleunigt und die Qualität des Endprodukts gewährleistet.

4. Praktische Umsetzung und Prüfung

Das untersuchte MQL5-Testskript ist ein praktisches Beispiel für die Integration dieser Programmiersprache mit einer externen, in FastAPI integrierten API, die im Kontext des Tic-Tac-Toe-Spiels angewendet wird. Der Prozess ist in mehrere Phasen unterteilt, von denen jede für eine bestimmte Interaktion mit der API verantwortlich ist:

Das Skript beginnt mit der Ermittlung der FastAPI-API-Adresse:

input string apiUrl = "http://localhost:8000";

Diese Zeile definiert die Basis-API-URL, mit der wir Anfragen an den FastAPI-Server senden. Diese Einstellung ist notwendig, um sicherzustellen, dass das Skript korrekt mit der API interagieren kann.

Funktion zum Drucken von API-Antworten

void PrintResponse(string response) {
    Print("Resposta da API: ", response);
}

Diese Hilfsfunktion dient dazu, von der API empfangene Antworten in das MQL5-Protokoll auszugeben. Sie liefert nützliche Informationen über das Ergebnis jedes eingereichten Antrags.

Initialisierung und erste Anfrage

void OnStart() {
    string response;
    int startGameRes = Request("GET", response, apiUrl + "/start-game/");
    // ...
}

OnStart ist die Hauptfunktion des Skripts. Durch Senden einer GET-Anfrage an die API starten wir ein neues Spiel. Die Variable startGameRes speichert das Ergebnis dieser Anfrage, das angibt, ob sie erfolgreich war.

Verarbeitung der Antwort und Start des Spiels

string gameIdStr = StringSubstr(response, StringFind(response, ":") + 1);
uint gameId = StringToInteger(gameIdStr);

Nachdem das Skript eine Antwort von der API erhalten hat, extrahiert es daraus die Spiel-ID. Diese ID ist für nachfolgende Spiele sehr wichtig, da sie die aktuelle Spielsitzung identifiziert.

Ziehen

string jsonMove1 = "{\"row\": 0, \"col\": 0}";
// ...
int playRes1 = Request("POST", response, apiUrl + "/play/" + IntegerToString(gameId) + "/", jsonMove1);

Das Skript führt dann eine Reihe von Spielzügen aus, die jeweils durch ein JSON-Objekt dargestellt wird, das die Koordinaten des Zuges auf dem Spielbrett enthält. Diese Züge werden über POST-Anfragen an die API gesendet. Dieser Vorgang wird für jeden weiteren Zug wiederholt.

Analyse des Spielverlaufs

• Start: Das Spiel beginnt, wir bekommen eine Spiel-ID.
• Spielzug: Es werden drei Züge gemacht, abwechselnd zwischen den Spielern.
• Rückmeldung: Nach jedem Spiel verarbeitet das Skript die API-Antwort, um zu prüfen, ob der Spielstatus aktualisiert wurde.

Perzeption:

• Wirksame Integration: Das Skript demonstriert die effektive Integration zwischen MQL5 und FastAPI API und zeigt, wie MQL5 zur Interaktion mit einer externen Anwendung verwendet werden kann.
• Flexibles Modell: Dieses Beispiel dient als flexibles Modell für andere Arten von Anwendungen und demonstriert die Fähigkeit von MQL5, sich in externe APIs zu integrieren.
• Praktische Anwendbarkeit: Dieses Skript ist ein praktisches Beispiel für die Kombination von MQL5-Programmierung und der Flexibilität der Python-API unter Verwendung von FastAPI, was den Weg für neue Innovationen in der Interaktion zwischen verschiedenen Systemen öffnet.

Dieses MQL5-Testskript veranschaulicht nicht nur die theoretischen Konzepte der Systemintegration, sondern bietet auch eine praktische Anwendung, die die Verflechtung und Anpassungsfähigkeit bei der Programmierung moderner Systeme hervorhebt.

Schlussfolgerung

Dieser Artikel zeigt, dass eine Reise durch die Welt der Programmierung immer voller Entdeckungen ist. In dieser Phase betrachten wir die Entwicklung von MQL5-Funktionen für die Verarbeitung von HTTP-Aufrufen, die auf den ersten Blick technisch etwas kompliziert erscheinen mögen, aber in Wirklichkeit ein ganzes Universum von Möglichkeiten eröffnen.

Wenn wir an MQL5 denken, assoziieren wir es in der Regel direkt mit dem Handel, aber wer hätte gedacht, dass es für etwas ganz anderes verwendet werden kann, zum Beispiel, um ein in Python entwickeltes Tic-Tac-Toe-Spiel laufen zu lassen? Dies zeigt, dass eine Programmiersprache weit über unser übliches Verständnis hinaus Anwendung finden kann.

Apropos Python: Das Erstellen eines Tic-Tac-Toe-Spiels war eine lustige Art, das Programmieren in Aktion zu erleben. Dies ist ein praktisches Beispiel, das hilft, besser zu verstehen, wie verschiedene Sprachen und Technologien miteinander verbunden werden können.

Die Wahl von FastAPI zur Erstellung der API war strategisch. FastAPI ist schnell, effizient und einfach zu bedienen und hat sich als hervorragendes Werkzeug erwiesen, um eine Brücke zwischen unserem Spiel und MQL5 zu schlagen. Es ist interessant zu sehen, wie eine API, die nur als technischer Vermittler erscheinen mag, tatsächlich eine Schlüsselrolle bei der Verbindung der verschiedenen Welten der Programmierung spielt.

Schließlich haben wir ein Testskript in MQL5 erstellt. Wir haben alles in der Praxis getestet, um zu sehen, wie sich die Theorie in die Realität umsetzen lässt. Hier sind wir von dem Potenzial der Integration dieser Technologien überzeugt. Das Drehbuch zeigt, dass wir mit ein wenig Kreativität und technischem Wissen erstaunliche Dinge schaffen können.

Was haben wir also aus all dem gelernt? Die Programmierung ist ein weites Feld mit vielen Überraschungen und Möglichkeiten. MQL5 und Python sind nur einige der Werkzeuge, die uns zur Verfügung stehen und die, wenn sie zusammen verwendet werden, unerwartete und innovative Lösungen schaffen können. Und was vielleicht am wichtigsten ist: In der Welt der Technologie gibt es immer etwas Neues zu lernen und zu entdecken.