Come chiamare una funzione Python da Node.js

Ho un'applicazione Express Node.js, ma ho anche un algoritmo di apprendimento automatico da utilizzare in Python. Esiste un modo per chiamare le funzioni Python dalla mia applicazione Node.js per sfruttare la potenza delle librerie di machine learning?

Il modo più semplice che conosco è usare il pacchetto "child_process" che viene fornito con il nodo.

Quindi puoi fare qualcosa del tipo:

const spawn = require("child_process").spawn;
const pythonProcess = spawn('python',["path/to/script.py", arg1, arg2, ...]);

Quindi tutto quello che devi fare è assicurarti di essere import sysnel tuo script Python, e quindi puoi accedere arg1usando sys.argv[1], arg2usando sys.argv[2]e così via.

Per rimandare i dati al nodo basta fare quanto segue nello script python:

print(dataToSendBack)
sys.stdout.flush()

E quindi il nodo può ascoltare i dati usando:

pythonProcess.stdout.on('data', (data) => {
    // Do something with the data returned from python script
});

Poiché ciò consente a più argomenti di essere passati a uno script tramite spawn, è possibile ristrutturare uno script Python in modo che uno degli argomenti decida quale funzione chiamare e l'altro argomento venga passato a quella funzione, ecc.

Spero fosse chiaro. Fammi sapere se qualcosa ha bisogno di chiarimenti.

Esempio per persone che provengono da Python e desiderano integrare il proprio modello di apprendimento automatico nell'applicazione Node.js:

Utilizza il child_processmodulo principale:

const express = require('express')
const app = express()

app.get('/', (req, res) => {

    const { spawn } = require('child_process');
    const pyProg = spawn('python', ['./../pypy.py']);

    pyProg.stdout.on('data', function(data) {

        console.log(data.toString());
        res.write(data);
        res.end('end');
    });
})

app.listen(4000, () => console.log('Application listening on port 4000!'))

Non richiede sysmodulo nel tuo script Python.

Di seguito è riportato un modo più modulare di eseguire l'attività utilizzando Promise:

const express = require('express')
const app = express()

let runPy = new Promise(function(success, nosuccess) {

    const { spawn } = require('child_process');
    const pyprog = spawn('python', ['./../pypy.py']);

    pyprog.stdout.on('data', function(data) {

        success(data);
    });

    pyprog.stderr.on('data', (data) => {

        nosuccess(data);
    });
});

app.get('/', (req, res) => {

    res.write('welcome\n');

    runPy.then(function(fromRunpy) {
        console.log(fromRunpy.toString());
        res.end(fromRunpy);
    });
})

app.listen(4000, () => console.log('Application listening on port 4000!'))

Il python-shellmodulo extrabaconè un modo semplice per eseguire script Python da Node.js con comunicazioni tra processi di base, ma efficienti e una migliore gestione degli errori.

Installazione: npm install python-shell .

Esecuzione di un semplice script Python:

var PythonShell = require('python-shell');

PythonShell.run('my_script.py', function (err) {
  if (err) throw err;
  console.log('finished');
});

Esecuzione di uno script Python con argomenti e opzioni:

var PythonShell = require('python-shell');

var options = {
  mode: 'text',
  pythonPath: 'path/to/python',
  pythonOptions: ['-u'],
  scriptPath: 'path/to/my/scripts',
  args: ['value1', 'value2', 'value3']
};

PythonShell.run('my_script.py', options, function (err, results) {
  if (err) 
    throw err;
  // Results is an array consisting of messages collected during execution
  console.log('results: %j', results);
});

Per la documentazione completa e il codice sorgente, consultare https://github.com/extrabacon/python-shell

Ora puoi usare le librerie RPC che supportano Python e Javascript come zerorpc

Dalla loro prima pagina:

Client Node.js

var zerorpc = require("zerorpc");

var client = new zerorpc.Client();
client.connect("tcp://127.0.0.1:4242");

client.invoke("hello", "RPC", function(error, res, more) {
    console.log(res);
});

Python Server

import zerorpc

class HelloRPC(object):
    def hello(self, name):
        return "Hello, %s" % name

s = zerorpc.Server(HelloRPC())
s.bind("tcp://0.0.0.0:4242")
s.run()

La maggior parte delle risposte precedenti chiama il successo della promessa in on ("dati"), non è il modo corretto di farlo perché se ricevi molti dati otterrai solo la prima parte. Invece devi farlo sull'evento finale.

const { spawn } = require('child_process');
const pythonDir = (__dirname + "/../pythonCode/"); // Path of python script folder
const python = pythonDir + "pythonEnv/bin/python"; // Path of the Python interpreter

/** remove warning that you don't care about */
function cleanWarning(error) {
    return error.replace(/Detector is not able to detect the language reliably.\n/g,"");
}

function callPython(scriptName, args) {
    return new Promise(function(success, reject) {
        const script = pythonDir + scriptName;
        const pyArgs = [script, JSON.stringify(args) ]
        const pyprog = spawn(python, pyArgs );
        let result = "";
        let resultError = "";
        pyprog.stdout.on('data', function(data) {
            result += data.toString();
        });

        pyprog.stderr.on('data', (data) => {
            resultError += cleanWarning(data.toString());
        });

        pyprog.stdout.on("end", function(){
            if(resultError == "") {
                success(JSON.parse(result));
            }else{
                console.error(`Python error, you can reproduce the error with: \n${python} ${script} ${pyArgs.join(" ")}`);
                const error = new Error(resultError);
                console.error(error);
                reject(resultError);
            }
        })
   });
}
module.exports.callPython = callPython;

Chiamata:

const pythonCaller = require("../core/pythonCaller");
const result = await pythonCaller.callPython("preprocessorSentiment.py", {"thekeyYouwant": value});

pitone:

try:
    argu = json.loads(sys.argv[1])
except:
    raise Exception("error while loading argument")

Sono sul nodo 10 e processo figlio 1.0.2. I dati di Python sono un array di byte e devono essere convertiti. Solo un altro rapido esempio di come effettuare una richiesta http in python.

nodo

const process = spawn("python", ["services/request.py", "https://www.google.com"])

return new Promise((resolve, reject) =>{
    process.stdout.on("data", data =>{
        resolve(data.toString()); // <------------ by default converts to utf-8
    })
    process.stderr.on("data", reject)
})

request.py

import urllib.request
import sys

def karl_morrison_is_a_pedant():   
    response = urllib.request.urlopen(sys.argv[1])
    html = response.read()
    print(html)
    sys.stdout.flush()

karl_morrison_is_a_pedant()

ps non è un esempio inventato poiché il modulo http del nodo non carica alcune richieste che devo fare

Potresti prendere il tuo pitone, traspilarlo e quindi chiamarlo come se fosse javascript. L'ho fatto con successo per i brividi e l'ho persino fatto funzionare nel browser alla brython .

/*eslint-env es6*/
/*global require*/
/*global console*/
var express = require('express'); 
var app = express();

// Creates a server which runs on port 3000 and  
// can be accessed through localhost:3000
app.listen(3000, function() { 
    console.log('server running on port 3000'); 
} ) 

app.get('/name', function(req, res) {

    console.log('Running');

    // Use child_process.spawn method from  
    // child_process module and assign it 
    // to variable spawn 
    var spawn = require("child_process").spawn;   
    // Parameters passed in spawn - 
    // 1. type_of_script 
    // 2. list containing Path of the script 
    //    and arguments for the script  

    // E.g : http://localhost:3000/name?firstname=Levente
    var process = spawn('python',['apiTest.py', 
                        req.query.firstname]);

    // Takes stdout data from script which executed 
    // with arguments and send this data to res object
    var output = '';
    process.stdout.on('data', function(data) {

        console.log("Sending Info")
        res.end(data.toString('utf8'));
    });

    console.log(output);
}); 

Questo ha funzionato per me. Il tuo python.exe deve essere aggiunto alle variabili di percorso per questo frammento di codice. Inoltre, assicurati che lo script python sia nella cartella del progetto.