Leo est un lycéen qui aime la programmation! !!
Cette fois, j'ai créé un service qui peut convertir les langues en temps réel. Je voudrais présenter et expliquer un peu comment cela a été fait.
L'idée est venue lorsque j'utilisais la fonction de traduction de WeChat. Quand je fais mes achats en Chine, j'ai parfois une conversation avec un employé en utilisant WeChat, mais ce n'est pas en temps réel et je traduis à chaque fois. Je ne pourrais pas me passer d'appeler, alors créons un service qui vous permet de traduire en temps réel et qui n'a pas à échanger d'amis! Je pensais que c'était le déclencheur.
Les langages de programmation utilisés sont Node.js et Python. J'utilise principalement Node.js et affiche des éléments de communication tels que Socket.io et des modèles (EJS) sur Node.js. Python utilise Python pour utiliser une bibliothèque appelée googletrans Les données sont échangées entre Node.js et Python à l'aide d'une bibliothèque appelée Python-Shell.
structure du fichier transchat
.
├── app.js
├── package-lock.json
├── package.json
├── public
│ ├── css
│ │ ├── chat
│ │ │ └── stylesheet.css
│ │ └── home
│ │ └── stylesheet.css
│ ├── img
│ │ └── button.svg
│ └── js
│ ├── chat
│ │ └── main.js
│ └── home
│ └── home.js
├── python
│ └── translate.py
└── templates
├── chat
│ └── index.ejs
└── home
└── index.ejs
En ce qui concerne la structure du fichier, un fichier python (translate.py) pour la conversion de langue a été ajouté à la structure express générale.
app.js
var express = require('express')
var app = express()
var http = require('http').createServer(app)
var io = require('socket.io')(http,{path:'/message'})
var uuid = require('node-uuid')
var {PythonShell} = require('python-shell')
app.use(express.static('public'))
app.set("view engine", "ejs")
var room = []
var lang = {}
app.get('/', function(req,res){
res.render(__dirname+'/templates/home/index.ejs')
})
app.post('/transroom', function(req,res){
var roomid = uuid.v4().split('-').join('')
room.push(roomid)
res.redirect('/transroom/'+roomid)
})
app.get('/transroom/:roomid', function(req, res){
if(room.includes(req.params.roomid)){
res.render(__dirname+'/templates/chat/index.ejs')
}else{
res.redirect('/')
}
})
function trans_mes(mes, before_lang, trans_lang, send_user){
if(1300 >= mes.length){
var pyshell = new PythonShell('./python/translate.py')
pyshell.send(JSON.stringify({'transdata':mes,'translang':trans_lang,'sendlang':before_lang}))
pyshell.on('message', function(data){
if(data == 'translate_error'){
io.to(send_user).emit('message', 'servererror')
}else{
io.to(send_user).emit('message', JSON.parse(data))
}
})
}else{
io.to(send_user).emit('message', 'error')
}
}
Voici le code principal de Node.js.
Les lignes 1 à 6 sont les bibliothèques requises, Express, Socket.io, Node-uuid, python-shell est en cours de lecture. Les lignes 7 et 8 spécifient le chemin du fichier public et le moteur de modèle.
Les lignes 16-20 créent un RoomID unique, ajoutent le RoomID au tableau de salles et redirigent l'utilisateur. Les lignes 22 à 28 vérifient si le RoomID demandé existe dans le tableau de salles, affichent le modèle si tel est le cas et redirigent si ce n'est pas le cas.
Dans la fonction trans_mes, récupérez le message à traduire, la langue de l'utilisateur émetteur, la langue de l'utilisateur de destination et l'ID de socket de la destination, et utilisez ces données pour exécuter Python avec Python-Shell et Socket les données traduites. J'envoie avec .io. Cependant, il existe une limite de caractères due à l'utilisation de googletrans, et nous vérifions le nombre de caractères avant d'exécuter python.
app.js
io.on('connection', function(socket){
var roomid = socket.handshake.headers.referer.split('/')[4]
if(roomid != null){
socket.join(roomid)
var room_user_count = io.sockets.adapter.rooms[roomid].length
if(room_user_count == 1){
io.to(socket.id).emit('sys', {'roomid':roomid})
}else if(room_user_count == 2){
socket.broadcast.to(roomid).emit('sys', 'join_user')
}else if(room_user_count >= 3){
io.to(socket.id).emit('sys', 'redirect')
}
socket.on('message', function(msg,sendlang){
var client_list = io.sockets.adapter.rooms[roomid].sockets
for (var clientId in client_list ) {
if(socket.id != clientId && lang[clientId]){
trans_mes(msg, lang[socket.id], lang[clientId], clientId)
}
}
})
socket.on('lang', function(user_lang){
lang[socket.id] = user_lang
})
socket.on('disconnect', function(){
socket.leave(roomid)
if(io.sockets.adapter.rooms[roomid] == null){
var list_room_id = room.indexOf(roomid)
if (list_room_id > -1) {
room.splice(list_room_id, 1)
}
}else{
if(io.sockets.adapter.rooms[roomid].length == 1){
socket.broadcast.to(roomid).emit('sys', {'user_out':roomid})
}
}
})
}
})
C'est la partie Socket.io.
Commencez par obtenir le RoomID demandé par `var roomid = socket.handshake.headers.referer.split ('/') [4]`, puis obtenez le RoomID demandé par socket.join (roomid)` Vous entrez dans la pièce avec ``.
app.js
socket.on('message', function(msg,sendlang){
var client_list = io.sockets.adapter.rooms[roomid].sockets
for (var clientId in client_list ) {
if(socket.id != clientId && lang[clientId]){
trans_mes(msg, lang[socket.id], lang[clientId], clientId)
}
}
})
Ensuite, en ce qui concerne la fonction de message, la partie var client_list = io.sockets.adapter.rooms [roomid] .sockets` obtient la liste des utilisateurs qui sont dans la salle.
app.rb
for (var clientId in client_list ) {
if(socket.id != clientId && lang[clientId]){
trans_mes(msg, lang[socket.id], lang[clientId], clientId)
}
}
Ensuite, divisez la liste des utilisateurs par For minutes, utilisez l'instruction if pour sélectionner un autre que l'expéditeur et exécutez la fonction trans_mes. Cela enverra le message traduit à des utilisateurs autres que l'expéditeur.
python/translate.py
from googletrans import Translator
import json
import sys
translator = Translator()
try:
data = sys.stdin.readline()
data_json = json.loads(data)
lang = data_json['translang']
sendlang = data_json['sendlang']
translate = translator.translate(data_json['transdata'], src=sendlang, dest=lang)
json = json.dumps({'trans_data':translate.text,'original_data':data_json['transdata'],'user_lang':lang,'trans_lang':translate.src},ensure_ascii=False)
print(json)
except Exception as e:
print('translate_error')
Le code Python est simple: obtenez les informations spécifiées dans Node.js avec sys.stdin.readline () '', traduisez-les en utilisant googletrans, et convertissez-les en Node.js au format Json. Je me convertis.
C'était la première fois que j'écrivais Socket.io jusqu'à présent, mais c'était assez facile et amusant. Cependant, le code est devenu compliqué pour un service simple, j'espère donc continuer à mettre à jour à l'avenir (Pururiku est le bienvenu!)
De plus, si vous le souhaitez, je serais heureux si vous pouviez l'installer et l'essayer.
git clone https://github.com/lra21711214/transchat.git
cd transchat
npm install
node app.js
Vous pouvez l'essayer simplement en installant Git et en installant npm comme ceci, alors s'il vous plaît! !!
※Mise en garde※ Lorsque vous l'utilisez réellement dans un environnement de production, enregistrez le tableau de salle et les informations de langue de l'utilisateur dans la base de données, puis enregistrez la partie traduction Amazon Translate, Cloud Translation, DeepL API, etc. S'il vous plaît. Ce n'est pas pour l'environnement de production, car il a été créé à titre d'essai.
Recommended Posts