Guía_de_implementación_de_MarketData_y_Order_Routing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Guía de implementación de MarketData y Order Routing",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JonaSiraQ/ToolBox-Python-DataScience/blob/main/Gu%C3%ADa_de_implementaci%C3%B3n_de_MarketData_y_Order_Routing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bo5rtGsN57cA"
      },
      "source": [
        "\n",
        "#Instalar pyRofex\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "87jYZWv4A2NF",
        "collapsed": true
      },
      "source": [
        "pip install -U pyRofex"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0GdWN53RBAnv"
      },
      "source": [
        "#Importar pyRofex y otros paquetes\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k-Lbym1zBCMz"
      },
      "source": [
        "import pyRofex"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-OStyFbOPp6S"
      },
      "source": [
        "from datetime import datetime\n",
        "import pandas as pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4yRstBsvSsEf"
      },
      "source": [
        "# Variables Globales\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xey-ZHtbD2iU"
      },
      "source": [
        "Crearemos algunas variables globales que nos permitirán almacenar la MarketData que vayamos recibiendo, así también como los reportes de nuestras órdenes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QQLmhdBjS2Wn"
      },
      "source": [
        "market_data_recibida = []\n",
        "reporte_de_ordenes = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VR7BtDjnBCej"
      },
      "source": [
        "# Autenticarse en la API\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JEfwuElLCyg7"
      },
      "source": [
        "\n",
        "\n",
        "> Consumir método /auth/getToken y almacenar internamente el token . El mismo dura hasta 24 hs y no cambia durante el día.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PQ_WF-2UBGr2"
      },
      "source": [
        "pyRofex.initialize(user=\"\",password=\"\",account=\"\",environment=pyRofex.Environment.REMARKET)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aNU3j608BHJN"
      },
      "source": [
        "\n",
        "# Solicitar la lista de instrumentos disponibles en el mercado\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JtGwmsxeDACC"
      },
      "source": [
        "\n",
        "\n",
        "> Consumir método /instruments/details y almacenar internamente la información. El listado no suele cambiar durante el día.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_u9kqfZnBK_V"
      },
      "source": [
        "repuesta_listado_instrumento = pyRofex.get_detailed_instruments()\n",
        "repuesta_listado_instrumento"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Q2n2EMBOqQ4"
      },
      "source": [
        "listado_instrumentos = repuesta_listado_instrumento['instruments']\n",
        "tickers_existentes = obtener_array_tickers(listado_instrumentos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1wjFCTFhBMsS"
      },
      "source": [
        "# Validar instrumentos de interés\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A1i3kMG8DJsl"
      },
      "source": [
        "\n",
        "\n",
        "> Si sólo queremos trabajar con algunos instrumentos, debemos validar que los mismos existen en la lista de instrumentos devuelto por la API.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gQ_eWMAlBVwQ"
      },
      "source": [
        "mis_instrumentos = [\"DLR/NOV22\", \"SOJ.ROS/MAY22\",\"DLR/JUN22\", \"MERV - XMEV - TSLA - 48hs\"]\n",
        "instrumentos_existentes = validar_existencia_instrumentos(mis_instrumentos,tickers_existentes)\n",
        "instrumentos_existentes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YWDKH-KpkMNx"
      },
      "source": [
        "# Conectarnos a la API WebSocket\n",
        "\n",
        "\n",
        "> Para poder trabajar en tiempo real con la API, debemos conectarnos previamente a la API WebSocket.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JePOqKPYkUd7"
      },
      "source": [
        "pyRofex.init_websocket_connection(market_data_handler,order_report_handler,error_handler,exception_error)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YtINJt0CBWQx"
      },
      "source": [
        "# Suscribirse a la MarketData\n",
        "\n",
        "\n",
        "> Una vez que ya tengamos nuestro listado de instrumentos de interés, y nos hayamos conectado a la API WebSocket, ya podemos suscribirnos vía este protocolo a la MarketData en tiempo real de los instrumentos. De esa manera, nuestro sistema quedará a la escucha de nuevas actualizaciones en el book de precios.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c0t40gfEBnfD"
      },
      "source": [
        "entries = [pyRofex.MarketDataEntry.BIDS,\n",
        "           pyRofex.MarketDataEntry.OFFERS,\n",
        "           pyRofex.MarketDataEntry.LAST]\n",
        "pyRofex.market_data_subscription(instrumentos_existentes,entries)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xYlMILvPB2H0"
      },
      "source": [
        "# Suscribirse a los Execution Reports\n",
        "\n",
        "\n",
        "> Antes de enviar una orden al mercado, es necesario que nos suscribamos vía WebSocket a los reportes de ejecución de las órdenes de nuestra cuenta. En estos reportes nos llegará el estado de cada orden que enviemos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LbPsG64DB7jw"
      },
      "source": [
        "pyRofex.order_report_subscription(snapshot=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M_0I4TH7CIyJ"
      },
      "source": [
        "# Desarrollar Reporte de Cuentas\n",
        "\n",
        "\n",
        "> Antes de enviar una orden, es necesario que validemos si nuestra cuenta posee el saldo necesario para que la orden ingrese al  mercado. Debe consultarse el método hasta una vez cada 5 segundos, o antes de enviar cada orden.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ew5MUJGOCOAP"
      },
      "source": [
        "def obtenerSaldoCuenta(cuenta=None):\n",
        "  resumenCuenta = pyRofex.get_account_report(account=cuenta)\n",
        "  return resumenCuenta[\"accountData\"][\"availableToCollateral\"]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "daS7oWyACPba"
      },
      "source": [
        "# Desarrollar Ruteo de órdenes\n",
        "\n",
        "\n",
        "> Las órdenes deben enviarse vía WebSocket a través de mensajes del tipo \"no\" (New Order)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nm4v8ZW-CVcN"
      },
      "source": [
        "def comprar(instrumento, cantidad, precio, tipoOrden):\n",
        "  saldo = obtenerSaldoCuenta()\n",
        "  if saldo >= cantidad * precio:\n",
        "    nuevaOrden = pyRofex.send_order(ticker=instrumento,side=pyRofex.Side.BUY,size=cantidad,price=precio,order_type=tipoOrden)\n",
        "    print(\"Orden de compra enviada {0}\".format(nuevaOrden))\n",
        "  else:\n",
        "    print(\"No hay suficiente saldo para enviar la orden de compra\")\n",
        "    return\n",
        "\n",
        "def vender(instrumento, cantidad, precio, tipoOrden):\n",
        "  saldo = obtenerSaldoCuenta()\n",
        "  if saldo >= cantidad * precio:\n",
        "    nuevaOrden = pyRofex.send_order(ticker=instrumento,side=pyRofex.Side.SELL,size=cantidad,price=precio,order_type=tipoOrden)\n",
        "    print(\"Orden de venta enviada {0}\".format(nuevaOrden))\n",
        "  else:\n",
        "    print(\"No hay suficiente saldo para enviar la orden de venta\")\n",
        "    return\n",
        "\n",
        "comprar('DLR/DIC21',25,108.25,pyRofex.OrderType.LIMIT)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pQakCwC2CVyi"
      },
      "source": [
        "# Desarrollar cancelación de órdenes\n",
        "\n",
        "\n",
        "> Es necesario que la cancelación de órdenes esté integrada para que una implementación tenga la posibilidad de cancelar una orden siempre que sea necesario.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GL1Jv7IjHRiN"
      },
      "source": [
        "def cancelarOrden(clientId):\n",
        "  cancel_order = pyRofex.cancel_order(clientId)\n",
        "  print(cancel_order)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuHYxb5Q_aUk"
      },
      "source": [
        "# Handlers\n",
        "\n",
        "\n",
        "> Desarrollaremos manejadores de eventos para poder procesar la mensajería websocket vayamos recibiendo. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hKrWFz2lBoDR"
      },
      "source": [
        "### Procesar la MarketData recibida\n",
        "\n",
        "\n",
        "> Una vez que nos hayamos suscripto a la MarketData, cada actualización que la API nos envíe, debemos procesarla. Aquí es donde entra en juego el objetivo de nuestra implementación, y qué queremos que nuestro sistema haga cuando recibe un nuevo update de MarketData.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BweCuGi8_onc"
      },
      "source": [
        "#Mensaje de MarketData: {'type': 'Md', 'timestamp': 1632505852267, 'instrumentId': {'marketId': 'ROFX', 'symbol': 'DLR/DIC21'}, 'marketData': {'BI': [{'price': 108.25, 'size': 100}], 'LA': {'price': 108.35, 'size': 3, 'date': 1632505612941}, 'OF': [{'price': 108.45, 'size': 500}]}}\n",
        "\n",
        "def market_data_handler(message):\n",
        "  print(message)\n",
        "  ticker = message[\"instrumentId\"][\"symbol\"]\n",
        "  bid = message[\"marketData\"][\"BI\"] if len(message[\"marketData\"][\"BI\"]) != 0 else [{'price': \"-\", 'size': \"-\"}]\n",
        "  offer = message[\"marketData\"][\"OF\"] if len(message[\"marketData\"][\"OF\"]) != 0 else [{'price': \"-\", 'size': \"-\"}]\n",
        "  last = message[\"marketData\"][\"LA\"][\"price\"] if message[\"marketData\"][\"LA\"] != None else 0\n",
        "  dateLA = message['marketData']['LA']['date'] if message[\"marketData\"][\"LA\"] != None else 0\n",
        "\n",
        "  timestamp = message['timestamp']\n",
        "  objeto_md = {'ticker':ticker,'bid':bid,'offer':offer,'last':last,'dateLA':dateLA,'timestamp':timestamp}\n",
        "  market_data_recibida.append(objeto_md)\n",
        "  print(\"Mensaje de MarketData: {0}\".format(message))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZxqQH5CK_8kt"
      },
      "source": [
        "### Procesar Execution Reports recibidos\n",
        "\n",
        "> Cuando nuestra orden se envíe, llegue al mercado, y vaya cambiando de estado, recibiremos un reporte de ejecución con el detalle de la orden y su estado actual. Debemos procesarlo internamente y tomar decisiones si se requiere."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ersfWUc-_pDa"
      },
      "source": [
        "#{\"type\":\"or\",\"orderReport\":{\"orderId\":\"1128056\",\"clOrdId\":\"user14545967430231\",\"proprietary\":\"api\",\"execId\":\"160127155448-fix1-1368\",\"accountId\":{\"id\":\"30\"},\"instrumentId\":{\"marketId\":\"ROFX\",\"symbol\":\"DODic21\"},\"price\":18.000,\"orderQty\":10,\"ordType\":\"LIMIT\",\"side\":\"BUY\",\"timeInForce\":\"DAY\",\"transactTime\":\"20160204-11:41:54\",\"avgPx\":0,\"lastPx\":0,\"lastQty\":0,\"cumQty\":0,\"leavesQty\":10,\"status\":\"CANCELLED\",\"text\":\"Reemplazada\"}}\n",
        "def order_report_handler(message):\n",
        "  print(\"Mensaje de OrderRouting: {0}\".format(message))\n",
        "  reporte_de_ordenes.append(message)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S1gGLEHJ-017"
      },
      "source": [
        "##Procesar errores o excepciones\n",
        "> Si recibimos algún error o excepción, tenemos que saber cómo debe interpretarlo nuestro desarrollo. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XuJ3TtjS_pVu"
      },
      "source": [
        "def error_handler(message):\n",
        "  print(\"Mensaje de error: {0}\".format(message))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7h6C4qPK_pjw"
      },
      "source": [
        "def exception_error(message):\n",
        "  print(\"Mensaje de excepción: {0}\".format(message))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bQTAEFNkCc9L"
      },
      "source": [
        "# Funciones útiles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8hrweRw0Nrgv"
      },
      "source": [
        "def obtener_array_tickers(listado):\n",
        "  listado_final = []\n",
        "  for inst in listado:\n",
        "    listado_final.append(inst['instrumentId']['symbol'])\n",
        "  return listado_final"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aMtYL9YTQRFm"
      },
      "source": [
        "def validar_existencia_instrumentos(mi_listado,listado_instrumentos):\n",
        "  listado_final = []\n",
        "  for instrumento in mi_listado:\n",
        "    if instrumento in listado_instrumentos:\n",
        "      print(f'El instrumento {instrumento} existe en el mercado')\n",
        "      listado_final.append(instrumento)\n",
        "    else:\n",
        "      print(f'El instrumento {instrumento} NO existe en el mercado')\n",
        "  return listado_final\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iahxrGSdXANP"
      },
      "source": [
        "def actualizarTablaMD():\n",
        "  df = pd.DataFrame(columns=pd.Index(['Ticker','Timestamp','Vol. Compra','Precio Compra', 'Precio Venta', 'Vol. Venta', 'Ult. Precio Operado']))\n",
        "  for md in market_data_recibida:\n",
        "    df = df.append(\n",
        "        {\n",
        "          'Ticker': md['ticker'],\n",
        "          'Timestamp':datetime.fromtimestamp(int(md['timestamp'])/1000),\n",
        "          'Vol. Compra':md['bid'][0]['size'],\n",
        "          'Precio Compra':md['bid'][0]['price'],\n",
        "          'Precio Venta': md['offer'][0]['price'],\n",
        "          'Vol. Venta': md['offer'][0]['size'],\n",
        "          'Ult. Precio Operado': md['last']}, \n",
        "          ignore_index=True)\n",
        "  return df.style.set_table_styles(\n",
        "      [{'selector': 'tr:hover',\n",
        "        'props': [('background-color', 'yellow'),('color', 'black')]},\n",
        "      {'selector': 'thead',\n",
        "        'props': [('font-size', '16px'),('padding', '8px'),('background-color','brown')]}]\n",
        "      )\n",
        "\n",
        "actualizarTablaMD()\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ktRb4fofwEeq"
      },
      "source": [
        "#{'type': 'or', 'timestamp': 1631140826238, 'orderReport': {'orderId': '220805706', 'clOrdId': 'eMSofNm4oXL92V_s', 'proprietary': 'PBCP', 'execId': '210908063630-fix1-2229680', 'accountId': {'id': 'REM2747'}, 'instrumentId': {'marketId': 'ROFX', 'symbol': 'GGAL/DIC21'}, 'price': 192.0, 'orderQty': 10, 'ordType': 'LIMIT', 'side': 'BUY', 'timeInForce': 'DAY', 'transactTime': '20210908-13:11:04.214-0300', 'avgPx': 0, 'lastPx': 0, 'lastQty': 0, 'cumQty': 0, 'leavesQty': 10, 'status': 'NEW', 'text': 'Aceptada '}}\n",
        "def actualizarTablaOR():\n",
        "\n",
        "  df = pd.DataFrame(columns=pd.Index(['Timestamp', 'ID Orden', 'Estado', 'Ticker', 'Precio', 'Cantidad', 'Tipo Orden', 'TIF', 'Cuenta', 'Precio Promedio', 'Cantidad Operada', 'Cantidad Remanente', 'TextoAPI']))\n",
        "  for order in reporte_de_ordenes:\n",
        "    if order['orderReport']['status'] != \"PENDING_NEW\" and order['orderReport']['status'] != \"PENDING_CANCEL\" :\n",
        "      df = df.append(\n",
        "          {\n",
        "              'Timestamp': datetime.fromtimestamp(int(order['timestamp'])/1000),\n",
        "              'ID Orden':order['orderReport']['orderId'], \n",
        "              'Estado':order['orderReport']['status'], \n",
        "              'Ticker':order['orderReport']['instrumentId']['symbol'], \n",
        "              'Precio':order['orderReport']['price'],\n",
        "              'Cantidad':order['orderReport']['orderQty'], \n",
        "              'Tipo Orden':order['orderReport']['ordType'], \n",
        "              'TIF': order['orderReport']['timeInForce'],\n",
        "              'Cuenta': order['orderReport']['accountId']['id'],\n",
        "              'Precio Promedio': order['orderReport']['avgPx'],\n",
        "              'Cantidad Operada': order['orderReport']['cumQty'],\n",
        "              'Cantidad Remanente': order['orderReport']['leavesQty'],\n",
        "              'TextoAPI': order['orderReport']['text']}, ignore_index=True)\n",
        "    else:\n",
        "        df = df.append(\n",
        "          {\n",
        "              'Timestamp': datetime.fromtimestamp(int(order['timestamp'])/1000),\n",
        "              'ID Orden':order['orderReport']['orderId'], \n",
        "              'Estado':order['orderReport']['status'], \n",
        "              'Ticker':order['orderReport']['instrumentId']['symbol'], \n",
        "              'Precio':order['orderReport']['price'],\n",
        "              'Cantidad':order['orderReport']['orderQty'], \n",
        "              'Tipo Orden':order['orderReport']['ordType'], \n",
        "              'TIF': order['orderReport']['timeInForce'],\n",
        "              'Cuenta': order['orderReport']['accountId']['id'],\n",
        "              'Precio Promedio': \"-\",\n",
        "              'Cantidad Operada': \"-\",\n",
        "              'Cantidad Remanente': \"-\",\n",
        "              'TextoAPI': order['orderReport']['text']}, ignore_index=True)\n",
        "  \n",
        "  df = df.sort_values(by=['Timestamp'],ascending=False)\n",
        "  return df\n",
        "\n",
        "actualizarTablaOR()\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}