¿Cómo comunicar datos JSON entre Python y Node.js?

El siguiente artículo cubre cómo comunicar datos JSON entre Python y Node.js. Supongamos que estamos trabajando con la aplicación Node.js y queremos hacer uso de una biblioteca específica que solo está disponible en python o viceversa. Deberíamos poder compartir los resultados de un idioma a otro y para lograrlo, usaremos JSON ya que es independiente del idioma.

Acercarse:

1. Configure un servidor para cada idioma y comparta datos usando JSON usando las viejas requests GET y POST.
2. Llame a un proceso en segundo plano de Python desde Node.js o viceversa y escuche el flujo de salida estándar del proceso en ambas instancias.

Estructura del proyecto: todos los archivos utilizados a continuación están presentes en el mismo directorio que se muestra a continuación.

Estructura de archivos

1. Uso de servidores: esto es similar al enfoque de usar un servicio API de terceros en el que hacemos una solicitud GET al servidor remoto para obtener los datos y una solicitud POST para enviar los datos. La única diferencia es que ejecutaremos los servidores localmente (esto también funcionaría en los servidores remotos con la URL requerida).

Node.js a Python: cuando estamos trabajando en node.js y queremos procesar algunos datos en python.

En el siguiente ejemplo, configuraremos un servidor para Python y realizaremos requests desde node.js. Estamos utilizando el micro framework Flask ya que esta es la forma más sencilla de configurar un servidor en Python y para realizar requests en Node.js necesitaremos un paquete de solicitud .

Instalación del módulo:

• Instale el módulo matraz para Python usando el siguiente comando:

  pip install flask

• Instale el módulo de solicitud para NodeJS usando el siguiente comando:

  npm install request-promise

Ejemplo: Calcule la suma de una array que contiene números enteros y devuelva el resultado a Node.js

from flask import Flask, request
import json 
   
# Setup flask server
app = Flask(__name__) 
  
# Setup url route which will calculate
# total sum of array.
@app.route('/arraysum', methods = ['POST']) 
def sum_of_array(): 
    data = request.get_json() 
    print(data)
  
    # Data variable contains the 
    # data from the node server
    ls = data['array'] 
    result = sum(ls) # calculate the sum
  
    # Return data in json format 
    return json.dumps({"result":result})
   
if __name__ == "__main__": 
    app.run(port=5000)

Ejecute el servidor con el siguiente comando.

python pyserver.py

Esto iniciará el servidor en http://127.0.0.1:5000/ . Ahora hacemos una solicitud POST desde Node.js a http://127.0.0.1:5000/arraysum

var request = require('request-promise');
  
async function arraysum() {
  
    // This variable contains the data
    // you want to send 
    var data = {
        array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
  
    var options = {
        method: 'POST',
  
        // http:flaskserverurl:port/route
        uri: 'http://127.0.0.1:5000/arraysum',
        body: data,
  
        // Automatically stringifies
        // the body to JSON 
        json: true
    };
  
    var sendrequest = await request(options)
  
        // The parsedBody contains the data
        // sent back from the Flask server 
        .then(function (parsedBody) {
            console.log(parsedBody);
              
            // You can do something with
            // returned data
            let result;
            result = parsedBody['result'];
            console.log("Sum of Array from Python: ", result);
        })
        .catch(function (err) {
            console.log(err);
        });
}
  
arraysum();

Ejecute este script con el siguiente comando.

node talk.js

Producción:

{ result: 55 }
Sum of Array from Python:  55

Python a Node.js: cuando estamos trabajando en python y queremos procesar algunos datos en Node.js.

Aquí revertiremos el proceso anterior y usaremos express para iniciar el servidor en node.js y solicitar el paquete en python. 

Instalación del módulo:

• Instale el módulo de solicitud para Python usando el siguiente comando:

  pip install requests

• Instale el módulo express y body-parser para NodeJS con el siguiente comando:

  npm install express
  npm install body-parser

var express = require('express');
var bodyParser = require('body-parser');
  
var app = express();
  
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
  
app.post("/arraysum", (req, res) => {
  
    // Retrieve array form post body
    var array = req.body.array;  
    console.log(array);
  
    // Calculate sum
    var sum = 0;
    for (var i = 0; i < array.length; i++) {
        if (isNaN(array[i])) {
            continue;
        }
        sum += array[i];
    }
    console.log(sum);
  
    // Return json response
    res.json({ result: sum });
});
  
// Server listening to PORT 3000
app.listen(3000);

Ejecute el servidor con el siguiente comando.

node nodeserver.js

Esto inicia el servidor en http://127.0.0.1:3000/ . Ahora hacemos una solicitud POST desde Python a 127.0.0.1:3000/arraysum 

import requests
  
# Sample array
array = [1,2,3,4,5,6,7,8,9,10]
  
# Data that we will send in post request.
data = {'array':array}
  
# The POST request to our node server
res = requests.post('http://127.0.0.1:3000/arraysum', json=data) 
  
# Convert response data to json
returned_data = res.json() 
  
print(returned_data)
result = returned_data['result'] 
print("Sum of Array from Node.js:", result)

Ejecute este script con el siguiente comando.

python talk.py 

Producción:

{'result': 55}
Sum of Array from Node.js: 55

2. Uso de procesos en segundo plano: en el siguiente ejemplo, nos comunicaremos generando un proceso de Python desde Node.js y viceversa, y escucharemos el flujo de salida estándar .

Node.js a Python: llamando al proceso de Python desde node.js. Implica los siguientes pasos:

1. Llamar al proceso de python y pasar datos JSON como un argumento de línea de comandos.
2. Lea esos datos en python, procéselos y envíelos a la transmisión estándar en formato JSON.
3. De nuevo, desde node.js, lea el flujo de salida y procese los datos JSON.

import sys, json
  
# Function to calculate the sum of array
def arraysum(arr):
    return sum(arr)
  
# Get the command line arguments
# and parse it to json
data = json.loads(sys.argv[1])
  
# Get the required field from
# the data
array = data['array']
  
# Calculate the result
result = arraysum(array)
  
# Print the data in stringified
# json format so that we can
# easily parse it in Node.js
newdata = {'sum':result}
print(json.dumps(newdata))

Ahora Python procesará la suma de la array y la imprimirá en la salida estándar como se muestra en el siguiente código.

const spawn = require('child_process').spawn;
  
// Initialise the data
const data = {
  array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
  
// We need to stringify the data as 
// python cannot directly read JSON
// as command line argument.
let stringifiedData = JSON.stringify(data);
  
// Call the python process and pass the
// data as command line argument.
const py = spawn('python', ['arraysum.py', stringifiedData]);
  
resultString = '';
  
// As the stdout data stream is chunked,
// we need to concat all the chunks.
py.stdout.on('data', function (stdData) {
  resultString += stdData.toString();
});
  
py.stdout.on('end', function () {
  
  // Parse the string as JSON when stdout
  // data stream ends
  let resultData = JSON.parse(resultString);
  
  let sum = resultData['sum'];
  console.log('Sum of array from Python process =', sum);
});

Ejecute este script con el siguiente comando:

node caller.js

Producción:

Sum of array from Python process = 55

Python a Node.js: llamando al proceso node.js desde python. Los pasos esencialmente siguen siendo los mismos que se mencionaron anteriormente con python y node.js intercambiando sus roles.

// Function to calculate sum of array
function arraysum(arr) {
  let sum = 0;
  for (var i = 0; i < arr.length; i++) {
    if (isNaN(arr[i])) {
      continue;
    }
    sum += arr[i];
  }
  return sum;
}
  
// Get the command line arguments and
// parse it to json
var data = JSON.parse(process.argv[2]);
  
// Get the required field form the data.
array = data['array'];
  
// Calculate the result.
var sum = arraysum(array);
  
// Print the data in stringified json
// format so that we can easily parse
// it in Python
const newData = { sum }
console.log(JSON.stringify(newData));

Ahora ejecute este proceso de Node.js desde python.

Nombre de archivo: llamador.py

from subprocess import Popen, PIPE
import json
  
# Initialise the data
array = [1,2,3,4,5,6,7,8,9,10]
data = {'array':array}
  
# Stringify the data.
stingified_data = json.dumps(data)
  
# Call the node process and pass the
# data as command line argument
process = Popen(['node', 'arraysum.js', 
        stingified_data], stdout=PIPE)
  
# This line essentially waits for the 
# node process to complete and then
# read stdout data
stdout = process.communicate()[0]
  
# The stdout is a bytes string, you can
# convert it to another encoding but
# json.loads() supports bytes string
# so we aren't converting
  
# Parse the data into json
result_data = json.loads(stdout)
array_sum = result_data['sum']
print('Sum of array from Node.js process =',array_sum)

Ejecute este script con el siguiente comando.

python caller.py

Producción:

Sum of array from Node.js process = 55