Cómo desarrollar un agente de aprendizaje por refuerzo en MQL5 con Integración RestAPI (Parte 2): Funciones MQL5 para interacción HTTP con API REST del juego de tres en raya

Introducción

En el artículo anterior, abordamos APIs y RestAPIs, resaltando cómo estas tecnologías cruciales facilitan la interconexión y el intercambio de datos entre distintos sistemas. Analizamos la evolución de las RestAPIs desde los principios de Roy Fielding y cómo han reemplazado protocolos más antiguos, como el SOAP, por alternativas más eficientes y flexibles. La importancia de la simplicidad, escalabilidad y versatilidad de las RestAPIs fue enfatizada, destacando su rol en el desarrollo de sistemas interconectados y avanzados.

En este nuevo artículo, vamos a expandir esos conceptos, aplicándolos a un ejemplo práctico. El foco será el desarrollo de un conjunto de funciones en MQL5 para trabajar con llamadas HTTP, integrando con las capacidades de las RestAPIs para una interacción eficiente con un ambiente externo. Para ello, usaremos el desarrollo de un tres en raya en Python como ejemplo práctico.

Iniciaremos con el desarrollo de funciones en MQL5. Estas funciones son esenciales para establecer una comunicación eficaz con el ambiente externo, en este caso, el tres en raya desarrollado en Python. Permitirán enviar solicitudes HTTP y recibir respuestas, actuando como puentes de comunicación entre el MQL5 y la API del juego.

Paralelamente, exploraremos el desarrollo de una API usando FastAPI, una elección motivada por sus características notables como alta performance, simplicidad en el desarrollo y fuerte soporte para APIs asíncronas. El FastAPI también se destaca en la integración con modernas herramientas de desarrollo de APIs, facilitando la creación de endpoints eficientes y escalables que nuestro conjunto de funciones en MQL5 podrá utilizar para interactuar con el tres en raya.

Tras establecer las funciones fundamentales en MQL5, elaboraremos un script de prueba diseñado para interactuar con la API Python. Este script será un elemento crucial para demostrar la aplicabilidad práctica de nuestras funciones MQL5 en el contexto del tres en raya.

Este ejemplo servirá no solo para ilustrar la aplicación práctica de los conceptos discutidos anteriormente, sino también para ofrecer insights valiosos sobre cómo estas tecnologías pueden ser utilizadas en conjunto para crear soluciones innovadoras.

Al final de este artículo, habremos explorado tanto el desarrollo técnico de las funciones en MQL5 y de la API en FastAPI como su rol en la construcción de sistemas interconectados.

Este artículo está dividido en cuatro partes principales:

1. Introducción y Contextualización: Revisitaremos brevemente los conceptos de APIs y RestAPIs discutidos en el artículo anterior, destacando la evolución y la importancia de estas tecnologías para la interconexión de sistemas.

2. Desarrollo de Funciones en MQL5 para Llamadas HTTP: Aquí, nos enfocaremos en el desarrollo de funciones específicas en MQL5. Estas funciones serán diseñadas para establecer y gestionar la comunicación vía HTTP, un paso fundamental para integrar MQL5 con entornos externos.

3. Creación e Integración de una API en FastAPI para el Tres en Raya: Esta sección tratará sobre el desarrollo de una API robusta utilizando FastAPI. La API servirá como base para nuestro ejemplo práctico -un tres en raya en Python- y será integrada con las funciones desarrolladas en MQL5.

4. Aplicación Práctica y Pruebas: En la parte final, implementaremos un script de prueba en MQL5 para interactuar con la API del tres en raya. Esta fase demostrará la integración práctica de las herramientas y conceptos discutidos, ilustrando cómo

       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("Jogada inválida. Tente novamente.")
   

   las funciones MQL5 pueden ser aplicadas en un contexto real.

Cada una de estas partes contribuirá al entendimiento completo de cómo las RestAPIs y MQL5 pueden ser utilizadas juntas para desarrollar soluciones interconectadas.

El diagrama arriba ilustra la secuencia de interacciones entre el script MQL5 y el tres en raya, con la API externa actuando como intermediaria. Iniciamos con una solicitud de inicio de juego por el script MQL5, que es procesada por la API externa. Esta, a su vez, invoca el tres en raya implementado en Python. Las jugadas son enviadas y recibidas a través de solicitudes HTTP, con la API externa gestionando la lógica de entrada y salida. El uso de FastAPI es crucial para la eficiencia de este proceso, permitiendo una comunicación asíncrona y de alto rendimiento. Este flujo nos permite visualizar la practicidad y la eficiencia de nuestro enfoque para la integración entre sistemas distintos.

1 - Introducción y contextualización

Prosiguiendo en nuestra serie, este artículo revisita y expande la discusión sobre APIs y RestAPIs, enfatizando su evolución y creciente importancia en la interconexión de sistemas digitales. Las APIs, fundamentales en la era de la digitalización, desempeñan un papel esencial en la integración de softwares distintos, asegurando comunicación y funcionamiento armónico. El surgimiento de las RestAPIs, notables por su arquitectura basada en la simplicidad y escalabilidad, representó un salto significativo, superando las limitaciones de protocolos antiguos como el SOAP y ofreciendo una opción más eficiente para la interacción entre sistemas. Este artículo se dedica a profundizar el conocimiento sobre estas interfaces, resaltando su funcionalidad, variedad y la arquitectura subyacente, y se propone explorar ejemplos prácticos de aplicación. Estamos pavimentando el camino para futuras discusiones más complejas y aplicaciones más específicas en los próximos artículos.

Las RestAPIs, introducidas en el cambio de milenio, rápidamente ganaron prominencia por su enfoque simplificado en comparación con protocolos como el SOAP, basado en XML y conocido por su complejidad y demanda por grandes volúmenes de datos para transacciones básicas. Emergiendo como una alternativa más ágil y versátil, las RestAPIs se establecieron en diversos sectores, incluido el financiero. Su facilidad de uso e implementación en casi todos los lenguajes de programación las hace particularmente atractivas para sistemas modernos que requieren de una comunicación efectiva y eficiente.

La aceptación generalizada de las RestAPIs se debe, en gran parte, a su naturaleza adaptable y al soporte a diversos formatos de datos, como JSON y XML, facilitando la interoperabilidad entre diferentes sistemas y plataformas. Además, la seguridad es un aspecto primordial en las RestAPIs, con mecanismos robustos como autenticación por token y criptografía, garantizando la protección de datos sensibles durante la comunicación. Este nivel de seguridad y flexibilidad es indispensable, especialmente en aplicaciones que manejan información crítica, como transacciones financieras y datos personales.

2 - Desarrollo de funciones en MQL5 para llamadas HTTP

En este artículo, comenzaremos una exploración detallada del desarrollo de funciones en MQL5 que posibilitan la realización de llamadas HTTP y la manipulación de datos JSON. Estas funciones desempeñan un papel crucial en la integración de programas MQL5 con entornos externos, permitiendo una comunicación efectiva con servicios web y la manipulación de información en formato JSON.

Además, es de suma importancia comprender el significado de los códigos de estado HTTP al tratar con llamadas HTTP. Estos códigos son retornados por los servidores web para indicar el resultado de una solicitud. Por ejemplo, un código de estado "200 OK" señaliza que la solicitud fue exitosa, mientras que un código "404 Not Found" indica que el recurso solicitado no fue encontrado en el servidor. Tener familiaridad con estos códigos es fundamental para el desarrollo de aplicaciones que interactúan con servicios web, ya que proporcionan información crucial sobre el estado de una solicitud HTTP.

Para una referencia completa y detallada de los códigos de estado HTTP, puedes consultar la documentación completa disponible en este enlace. Esto te permitirá profundizar aún más tu comprensión de estos códigos y utilizarlos con confianza en tus proyectos.

Función SendGetRequest - Realizando solicitudes GET

Comenzaremos nuestra exploración con la función SendGetRequest, una pieza central del proceso. Esta función ha sido cuidadosamente diseñada para realizar solicitudes HTTP de tipo GET. Acepta una serie de parámetros esenciales que ofrecen un alto grado de flexibilidad y control sobre la solicitud.

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

• url: La URL a la cual la solicitud GET será enviada.
• query_param: Parámetros de consulta opcionales que pueden ser adjuntados a la URL.
• out: Una variable de salida que almacenará la respuesta de la solicitud.
• headers: Encabezados HTTP opcionales que puedes proporcionar.
• timeout: Define el tiempo límite de la solicitud en milisegundos.

La función SendGetRequest desempeña un papel crucial en el proceso de manejar solicitudes GET, abarcando desde la construcción de la solicitud hasta el manejo de errores HTTP. Es importante destacar que, aunque el manejo de errores está presente en la función actualmente, es relativamente básico en su forma actual y está sujeto a mejoras en el futuro.

Cuando la respuesta es exitosa (indicada por un código de respuesta entre 200 y 204), la función realiza la decodificación de los datos a UTF-8 y los almacena en la variable "out". Esta funcionalidad es esencial para asegurar que los datos obtenidos sean manejados de manera adecuada y puedan ser utilizados en tus proyectos de manera efectiva.

Función SendPostRequest - Realizando solicitudes POST

Ahora, pasemos a la función SendPostRequest, que desempeña un papel fundamental al transmitir datos a servicios web externos, donde los cargamentos frecuentemente están en formato JSON. Esta función es esencial al crear o actualizar recursos por medio de APIs.

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

• url: La URL a la cual se enviará la solicitud POST.
• payload : Los datos de carga útil que serán enviados con la solicitud, frecuentemente en formato JSON.
• out: Una variable de salida que almacenará la respuesta de la solicitud.
• headers: Encabezados HTTP opcionales que puedes proporcionar.
• timeout: Define el tiempo límite de la solicitud en milisegundos.

La función SendPostRequest simplifica el proceso de construcción de la solicitud POST, anexión de encabezados y manejo de errores HTTP, aunque es importante notar que el manejo de errores actual es bastante superficial y está sujeto a mejoras futuras, similar a lo que ocurre con la función SendGetRequest. Cuando la respuesta es exitosa (código de respuesta entre 200 y 204), los datos se decodifican a UTF-8 y se almacenan en la variable "out".

Función Request - Un Enfoque Centralizado

La función Request actúa como un punto de entrada centralizado para realizar solicitudes tanto GET como POST, proporcionando un enfoque conveniente y flexible.

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

• method : Define el método HTTP a ser utilizado, "GET" o "POST".
• url: La URL a la cual se enviará la solicitud.
• payload : Los datos de carga útil a ser enviados en una solicitud POST (opcional).
• query_param: Parámetros de consulta opcionales para solicitudes GET.
• out: Una variable de salida que almacenará la respuesta de la solicitud.
• headers: Encabezados HTTP opcionales que puedes proporcionar.
• timeout: Define el tiempo límite de la solicitud en milisegundos.

La función Request actúa como una capa de abstracción, simplificando la elección entre GET y POST, sin la necesidad de preocuparse por detalles de implementación. Esto no solo simplifica el código, sino también mejora la legibilidad, haciendo el desarrollo para llamadas HTTP más eficiente y accesible.

      

Nuestra travesía por el desarrollo de estas funciones es fundamental para capacitarte en aprender cómo trabajar con llamadas HTTP de manera efectiva. Esto abrirá las puertas para integrar tus proyectos en MQL5 con una amplia gama de servicios web, capacitándote para enviar y recibir datos, aprovechando la potencia de las llamadas HTTP y el manejo eficiente de datos JSON. Vamos a continuar explorando estos recursos, guiándote paso a paso para que puedas perfeccionar tus habilidades de programación en MQL5 y convertirte en un experto en la interacción con servicios web a través de HTTP.

Además de dominar las llamadas HTTP en MQL5, es esencial comprender el formato JSON (JavaScript Object Notation). JSON es una forma efectiva y ampliamente adoptada de estructurar datos, frecuentemente utilizada para el intercambio de información entre sistemas. Aquí están algunos motivos por los cuales es crucial aprender a trabajar con JSON:

1. Formato Estándar Web: JSON es el formato de elección para muchas APIs web, lo que lo convierte en un elemento fundamental para la integración de aplicaciones y servicios externos. Al entender JSON, puedes fácilmente enviar y recibir datos de servicios web en una estructura que es ampliamente aceptada y comprendida.

2. Facilidad de Lectura y Escritura: JSON es conocido por su legibilidad. Utiliza una sintaxis simple y legible para humanos, haciendo más fácil para los desarrolladores entender y depurar los datos. Esto es especialmente importante al tratar con respuestas de APIs y al depurar solicitudes.

3. Flexibilidad y Anidamiento: JSON permite el anidamiento de objetos y arreglos, lo que es ideal para representar datos complejos y jerárquicos. Esto es fundamental cuando tratas con información detallada y estructurada.

4. Compatibilidad con Diversas Lenguajes: JSON es compatible con una amplia variedad de lenguajes de programación, lo que lo hace una elección versátil. Independientemente del lenguaje que estés usando, comprender JSON facilita la manipulación de datos.

La relevancia de JSON en las llamadas HTTP

Ahora que entendemos la importancia de JSON, es fundamental resaltar cómo se integra a las llamadas HTTP realizadas. Tanto para solicitudes de entrada (envío de datos) como para respuestas de salida (recepción de datos), JSON desempeña un papel central.

Al enviar datos a un servicio web, a menudo necesitarás formatearlos como JSON e incluirlos en la solicitud. Esto permite que el servicio entienda y procese esos datos de manera apropiada. Por otro lado, al recibir respuestas de servicios web, es común que los datos sean retornados en formato JSON. Por lo tanto, saber cómo analizar y extraer información de JSON se vuelve crucial.

Para simplificar aún más la manipulación de JSON en MQL5, opté por utilizar la biblioteca JAson, que está escrita en MQL5 nativo, eliminando la necesidad de usar DLLs externas. Es importante destacar que esta elección estratégica se hizo teniendo en cuenta la notable simplicidad de uso y la eficacia probada de la biblioteca. Ahora, vamos a explorar detalladamente por qué la biblioteca JAson es una excelente opción para manejar JSON en tus proyectos MQL5:

1. Facilidad de Uso: Una de las principales ventajas de la biblioteca JAson es su facilidad de uso. Fue diseñada para simplificar la manipulación de JSON, haciendo las operaciones de lectura, escritura y manipulación de objetos JSON accesibles incluso para programadores principiantes. Con una sintaxis intuitiva y funcionalidades bien pensadas, ahorrarás tiempo y esfuerzo al trabajar con JSON.

2. Abstracción Conveniente: La biblioteca JAson ofrece una abstracción conveniente para JSON. Esto significa que no necesitas lidiar con los detalles del análisis y serialización manualmente. En su lugar, puedes usar métodos y funciones proporcionados por la biblioteca para realizar tareas comunes, como acceder a propiedades de objetos JSON, añadir elementos a arreglos JSON y crear estructuras JSON complejas.

3. Mejora en la Legibilidad del Código: Trabajar directamente con JSON en tu código MQL5 puede ser complicado y resultar en código confuso. Sin embargo, al adoptar la biblioteca JAson, ganas la ventaja de un código más legible y organizado. Las operaciones relacionadas con JSON se simplifican, lo que hace que tu código sea más fácil de comprender y mantener.

4. Eficiencia en el Desarrollo: La eficiencia es clave durante el desarrollo de proyectos. La biblioteca JAson ayuda a acelerar el proceso de desarrollo, permitiéndote concentrarte en la lógica de negocio en lugar de preocuparte por el manejo detallado de JSON. Esto significa que puedes implementar funcionalidades más rápidamente y con menos errores.

3 - Creación e integración de una API en FastAPI para el tres en raya

Vamos a comenzar nuestro ejemplo práctico explorando el código de un tres en raya en Python. Este es un paso fundamental en el desarrollo de la interacción entre MQL5 y Python, ya que el tres en raya servirá como el entorno con el cual MQL5 interactuará.

La clase TicTacToe:

import random

class TicTacToe:

Aquí, importamos el módulo random y creamos una clase llamada TicTacToe. Una clase es una estructura de programación que organiza funciones y variables relacionadas. En este caso, la clase TicTacToe representa el juego del tres en raya.

Inicialización del tablero:

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

En este fragmento, estamos definiendo el método __init__, que es un método especial que se llama cuando se crea una instancia de la clase. Inicializa el estado del juego.

• self.board es una lista bidimensional (3x3) que representa el tablero del juego. Inicialmente, todas las celdas están vacías (representadas por espacios en blanco).
• self.player_turn es una variable booleana que rastrea de quién es el turno de jugar. Inicialmente, es el turno del primer jugador (True).

Método print_board:

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

Este método print_board es responsable de imprimir el estado actual del tablero en la pantalla. Recorre las filas del tablero e imprime los elementos separados por barras verticales ('|') y líneas horizontales ('-----') para crear la representación visual del tablero.

Método 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

El método check_winner verifica si hay un ganador en el juego. Revisa todas las filas, columnas y diagonales para ver si hay tres símbolos consecutivos del mismo jugador ('X' o 'O'). Si un jugador gana, el símbolo de ese jugador se retorna (por ejemplo, 'X' si el jugador 'X' gana). Si no hay ganador, el método retorna None.

Método 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("Jogada inválida. Tente novamente.")

El método make_move es responsable de realizar un movimiento en el juego. Recibe las coordenadas de la fila y columna donde el jugador desea realizar el movimiento. Antes de hacer el movimiento, verifica si la celda en el tablero está vacía (' '). Si está vacía, se realiza el movimiento, y el símbolo del jugador ('X' o 'O') se coloca en la celda. Luego, el turno del jugador se alterna. Si la celda no está vacía, se imprime un mensaje de "Movimiento inválido".

El código anterior representa un punto crucial en nuestro proceso de integración entre MQL5 y Python. Desarrollar el tres en raya en Python es un paso fundamental, ya que servirá como el entorno en el cual nuestra interacción ocurrirá.

Al analizar cada aspecto de este código, podemos apreciar la simplicidad y eficacia con la que Python nos permite crear un juego funcional. Sin embargo, el verdadero potencial de este código se revelará cuando lo conectemos a MQL5, permitiendo que estas dos tecnologías distintas trabajen juntas de manera sinérgica.

Ahora que hemos establecido una base sólida con el tres en raya, estamos listos para dar el próximo paso emocionante: el desarrollo de una API en Python usando FastAPI. Esta API será el enlace de comunicación entre el MQL5 y el tres en raya, permitiendo que el MQL5 haga solicitudes y reciba respuestas para jugar el juego. Vamos a iniciar este proceso de desarrollo y explorar cómo la integración entre sistemas puede ser alcanzada con eficiencia y eficacia.

Ahora que ya estás familiarizado con la clase TicTacToe y cómo gestiona el tres en raya, vamos a analizar en detalle el código de la API FastAPI que se presenta arriba. Esta API desempeñará un papel fundamental en la interacción entre el MQL5 y el tres en raya Python que desarrollamos anteriormente. Vamos a entender cada parte de este código:

# Importação de Bibliotecas
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from tic_tac_toe import TicTacToe

# Criação da Instância FastAPI
app = FastAPI()

# Armazenamento de Jogos em Execução
games = {}

Comenzamos importando dos bibliotecas esenciales: FastAPI y Pydantic. FastAPI es un marco para el desarrollo rápido de APIs web en Python, mientras que Pydantic se utiliza para definir modelos de datos que describen la estructura de los datos esperados por la API.

# Definição de Modelos de Dados
class GameBoard(BaseModel):
    board: list
    player_turn: str

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

A continuación, definimos dos modelos de datos utilizando Pydantic. El GameBoard representa el estado actual del tablero del juego y contiene una lista llamada board para almacenar las celdas del tablero y una cadena player_turn para indicar de quién es el turno de jugar. El PlayerMove representa una jugada que un jugador desea hacer e incluye las coordenadas row (fila) y col (columna) de la jugada.

# Definição de Endpoints da API

# Endpoint para iniciar um novo jogo
@app.get("/start-game/")
def start_game():
    game_id = len(games) + 1
    game = TicTacToe()
    games[game_id] = game
    return {"game_id": game_id}

# Endpoint para fazer uma jogada no jogo
@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 o método print_board para imprimir o estado atual do jogo
    game.print_board()

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

La API posee dos endpoints principales. El primer endpoint, /start-game/, permite iniciar un nuevo juego del tres en raya. Crea una instancia de la clase TicTacToe para representar el juego y la asocia a un ID único en el diccionario games. El ID del juego se devuelve como respuesta.

El segundo endpoint, /play/{game_id}/, permite que los jugadores hagan sus jugadas en un juego existente. Recibe un ID de juego como parámetro y los datos de la jugada del jugador. La API verifica si el juego con el ID proporcionado existe en el diccionario games. Si no existe, devuelve un error 404. Luego, intenta hacer la jugada en el juego y actualiza el estado del tablero. El estado actual del tablero se devuelve como respuesta.

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

Finalizamos el código ejecutando la API utilizando Uvicorn. Esto permite que la API sea accesada por otras aplicaciones. 

Documentación de la API, generada automáticamente

FastAPI es un marco moderno y rápido para construir APIs con Python 3.6+ que se basa en estándares de Python type hints. Su simplicidad reside en su capacidad para permitir una codificación rápida, eficiente y robusta, con énfasis en las siguientes características:

1. Rapidez y Desempeño: FastAPI es uno de los frameworks más rápidos para Python, gracias a su uso de Starlette para el enrutamiento y Uvicorn para la ejecución del servidor ASGI. Esto lo hace ideal para aplicaciones que requieren alto rendimiento.

2. Generación Automática de Documentación: Con FastAPI, la documentación de tu API se genera automáticamente y se actualiza con los cambios del código. Esto es posible gracias al uso de los type hints de Python y a los sistemas de documentación integrados como Swagger UI y ReDoc.

3. Validación de Datos y Serialización: Utilizando Pydantic, FastAPI ofrece un sistema robusto para la validación de datos. Las solicitudes y respuestas son automáticamente validadas y serializadas, reduciendo la cantidad de código necesario y evitando muchos errores comunes.

4. Facilidad de Uso: FastAPI está diseñado para ser fácil de usar, con un aprendizaje intuitivo. Esto hace más simple para los desarrolladores crear y mantener APIs eficientes, con una curva de aprendizaje menos pronunciada en comparación con otros frameworks.

5. Soporte a Operaciones Asíncronas: Con soporte nativo para operaciones asíncronas, FastAPI es adecuado para aplicaciones que necesitan manejar solicitudes simultáneas, como servicios en tiempo real.

6. Seguridad y Autenticación: El framework también proporciona herramientas para implementar seguridad en la API, incluyendo soporte para OAuth2 con tokens JWT y otras estrategias de autenticación.

El uso de FastAPI en la creación de una API demuestra claramente su eficacia y simplicidad. Este framework proporciona una integración perfecta entre diferentes tecnologías, como MQL5 y Python, y permite el desarrollo rápido de aplicaciones web de alto rendimiento. Al emplear FastAPI, los desarrolladores pueden enfocarse más en la lógica de negocios y menos en los detalles técnicos de la implementación de una API, acelerando el proceso de desarrollo y garantizando la calidad del producto final.

4 - Aplicación práctica y pruebas

El script de prueba MQL5 en análisis es un ejemplo práctico de cómo integrar este lenguaje de programación con una API externa construida en FastAPI, aplicada en el contexto de un tres en raya. El proceso se divide en varias etapas, cada una cumpliendo una función específica en la interacción con la API:

El script comienza estableciendo la dirección de la API FastAPI:

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

Esta línea define la URL base de la API, que será usada para enviar solicitudes al servidor FastAPI. Esta configuración es esencial para asegurar que el script se comunique con la API correctamente.

Función para imprimir respuestas de la API

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

Esta función auxiliar está diseñada para imprimir las respuestas recibidas de la API en el log de MQL5. Proporciona un feedback útil sobre el resultado de cada solicitud enviada.

Inicialización y primera solicitud

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

OnStart es la función principal del script. Inicia un nuevo juego enviando una solicitud GET a la API. La variable startGameRes almacena el resultado de esta solicitud, indicando si fue exitosa.

Procesamiento de la respuesta e inicio del juego

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

Tras recibir la respuesta de la API, el script extrae el ID del juego de la respuesta. Este ID es crucial para las jugadas subsiguientes, ya que identifica la sesión del juego actual.

Realización de las jugadas

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

El script luego realiza una serie de jugadas, cada una representada por un objeto JSON que contiene las coordenadas de la jugada en el tablero. Estas jugadas son enviadas a la API usando solicitudes POST. El proceso se repite para cada jugada subsiguiente.

Análisis del flujo de juego

• Inicio: El juego se inicia, y se obtiene el ID del juego.
• Jugadas: Se realizan tres jugadas, alternando entre los jugadores.
• Feedback: Después de cada jugada, el script procesa la respuesta de la API para verificar el estado actualizado del juego.

Percepciones:

• Integración Eficiente: El script demuestra una integración efectiva entre MQL5 y una API FastAPI, ilustrando cómo el MQL5 puede usarse para interactuar con una aplicación externa.
• Modelo Flexible: El ejemplo sirve como un modelo flexible para otros tipos de aplicaciones, evidenciando la capacidad del MQL5 de integrarse con APIs externas.
• Aplicabilidad Práctica: Este script es un ejemplo práctico de la unión entre la programación MQL5 y la flexibilidad de las APIs en Python usando FastAPI, abriendo camino para nuevas innovaciones en interacciones entre diferentes sistemas.

Este script de prueba MQL5 no solo ilustra los conceptos teóricos de integración de sistemas, sino que también ofrece una aplicación práctica, resaltando la interconectividad y adaptabilidad en la programación de sistemas modernos.

Conclusión

Llegando al final de este artículo, se puede ver que el viaje por el mundo de la programación siempre está lleno de descubrimientos. En esta etapa, nos sumergimos en el desarrollo de funciones MQL5 para manejar llamadas HTTP, algo que, a primera vista, puede parecer un poco técnico, pero que en realidad abre un universo de posibilidades.

Pensando en MQL5, normalmente lo asociamos directamente con trading, pero ¿quién diría que podría usarse para algo completamente diferente, como controlar un tres en raya hecho en Python? Esto muestra cómo un lenguaje de programación puede tener usos que van mucho más allá de lo que normalmente esperamos.

Y hablando de Python, crear un tres en raya fue una manera interesante de ver la programación en acción. Fue un ejemplo práctico que nos ayudó a entender mejor cómo diferentes lenguajes y tecnologías pueden conectarse.

La elección de FastAPI para crear la API fue estratégica. Rápido, eficiente y fácil de usar, FastAPI demostró ser una gran herramienta para construir el puente entre nuestro juego y el MQL5. Lo interesante es ver cómo la API, algo que puede parecer solo un intermediario técnico, en realidad juega un papel crucial en unir diferentes mundos de la programación.

Por último, el script de prueba en MQL5. Este fue el momento de probar todo en la práctica, de ver la teoría convertirse en realidad. Fue aquí donde realmente percibimos el potencial de la integración de estas tecnologías. Mostró que, con un poco de creatividad y conocimiento técnico, podemos crear cosas increíbles.

Entonces, ¿qué aprendimos con todo esto? Que la programación es un campo vasto, con muchas sorpresas y oportunidades. Que MQL5, Python son solo algunas de las herramientas que tenemos a disposición y que, cuando se utilizan juntas, pueden crear soluciones inesperadas e innovadoras. Y, quizás lo más importante, que siempre hay algo nuevo para aprender y explorar en el mundo de la tecnología.