Python is the language of choice for most Machine Learning code, but I prefer to run my back-end services using NodeJS. I'm currently working on a Node based project where I need to call the HuggingFace Diffusers module. So I have implemented an IPC wrapper around the Python script.
It works by sending JSON messages back and forth over stdin/out using U+0000 (NULL,\0) as a delimeter. This is one of the few characters that must be escaped in valid JSON. So we can be confident that no response should contain this character.
Since the Python script is blocking, we can send an arbitrary number of messages to it and they will be automatically buffered until the process can handle them.
Responses from the Python process are manually buffered until we receive the null byte and then decoded.
The Node Side
import { spawn } from 'child_process';
import { dirname, join } from 'path';
import { fileURLToPath } from 'url';
// Start the Python process
const __dirname = dirname(fileURLToPath(import.meta.url));
const pythonProcess = spawn('python3', [join(__dirname, 'example.py')]);
// Buffer for incomplete messages
let buffer = '';
// Handle incoming messages from Python
pythonProcess.stdout.on('data', (data) => {
// Split incoming data on null bytes
const messages = (buffer + data.toString()).split('\0');
// Store incomplete message
buffer = messages.pop();
// Process complete messages
for (const message of messages) {
try {
const response = JSON.parse(message);
console.log('Received from Python:', response);
} catch (error) {
console.error('Parse error:', error);
}
}
});
// Handle Python errors
pythonProcess.stderr.on('data', (data) => {
console.error('Python stderr:', data.toString());
});
// Send messages to Python
function sendToPython(message) {
pythonProcess.stdin.write(JSON.stringify(message) + '\n');
}
// Test the communication
sendToPython({ type: "test", message: "Hello Python!" });
The Python Side
import sys
import json
import time
def log_message(message):
# Write messages with null terminator as delimiter
sys.stdout.buffer.write(json.dumps(message).encode() + b'\0')
sys.stdout.buffer.flush()
if __name__ == "__main__":
log_message({"status": "ready"})
# Loop forever to keep the process active
while True:
try:
# Read input from Node
data = json.loads(input())
# Echo back with timestamp
log_message({
"status": "success",
"received": data,p
"timestamp": time.time()
})
except Exception as e:
log_message({
"status": "error",
"message": str(e)
})
This is bare-bones example of how to accomplish this. Stay tuned for more details about this project in the near future.
Top comments (4)
Super clean setup, always love seeing cross-language hacks come together like this. You ever hit messes with buffering or pipes going weird when stuff gets high volume?
So far I have not seen any issues, but I have not pushed it very hard yet. I'm sending messages over a WebSocket from the browser to Node that carry the parameters for diffusion. I have queued multiple requests across several instances of the client and the result always comes through properly.
I haven't come up with a way to trigger exactly simultaneous requests to see if that will work properly, but I think it should be fine. The requests are sent from Node to Python as a complete JSON body and should never be too large for the buffer.
It's the outputs that end up coming through in chunks due to the size of the base64 encoded image data. But the Python script can only process one request at a time so there is no chance of collisions.
The cover looks great! Looking forward to more details.
I know, right! They look so happy together. 😄 Thanks for reading!