Coverage for lib/lib_live/lib_wsns.py: 23%

212 statements  

« prev     ^ index     » next       coverage.py v7.9.1, created at 2026-01-26 23:58 +0100

1import asyncio 

2import datetime 

3import json 

4 

5import websockets 

6import wave 

7import os 

8import ssl 

9 

10class WebSocketLiveTranscriptParam(): 

11 def __init__(self, cert_args = None, key_args = None): 

12 self.interval_stream_audio = 3000 

13 self.duration_transcript = 6000 

14 self.nb_maximal_transcript_job_global = 20 

15 self.nb_maximal_websocket_server = 20 

16 

17 from auth.lib_conf_system import lcs_global_singleton 

18 

19 if cert_args != None: 

20 self.cert_args = cert_args 

21 else : 

22 self.cert_args = lcs_global_singleton.get_cert_ssl() 

23 

24 if key_args != None: 

25 self.key_args = key_args 

26 else : 

27 self.key_args = lcs_global_singleton.get_key_ssl() 

28 

29 self.hostname = "0.0.0.0" 

30 

31# DEV TO TEST 

32def server_stopped(websocket): 

33 print(" We are here since a server was stopped !") 

34 

35class WebSocketAllocator(): 

36 def __init__(self): 

37 self.map_live_streaming_websocket = {} 

38 self.default_param = WebSocketLiveTranscriptParam() 

39 

40 def create_web_socket(self, port = None, user_id = None, lss = None, protocol = "https", 

41 request_host = "safia.app", otp = None): 

42 if len(self.map_live_streaming_websocket) > self.default_param.nb_maximal_websocket_server: 

43 message = " We have too much running server, please try again later or ask to admin to stop some" 

44 print(message) 

45 return message 

46 

47 if port == None: 

48 # VR non test mais franchement ca doit marcher de la meme facon 

49 from lib.lib_util import get_random_port 

50 port = get_random_port() 

51 

52 if user_id == None: 

53 user_id = lss.get_user_id() 

54 

55 self.map_live_streaming_websocket[port] = {"port" : port, 

56 "running" : False, 

57 "user_id" : user_id, 

58 "created_at" : datetime.datetime.now(), 

59 "interval_stream_audio" : self.default_param.interval_stream_audio, 

60 "duration_transcript" : self.default_param.duration_transcript, 

61 "request_host" : request_host} 

62 

63 path_script = os.path.join(os.environ["GITSAFIA"], "prompt/python/lib/lib_live/lib_wsns.py") if "GITSAFIA" in os.environ else "../lib/lib_live/lib_wsns.py" 

64 

65 list_args_wss = ["python3.10", path_script, str(port), str(otp), ">", "wss_" + str(port) + ".log"] 

66 command = " python3.10 " + path_script + " " + str(port) + " " + str(otp) + " &" 

67 print(command) 

68# file = "cmd_" + str(port) + ".sh" 

69# with open(file, "w") as cmd: 

70# cmd.write(command) 

71# os.system(file + " &") 

72 

73# os.system(command) 

74 

75 self.map_live_streaming_websocket[port]["running"] = True 

76 

77 

78 

79 cmd = " ".join(list_args_wss) 

80 print(cmd) 

81 print(" But maybe we don't need to launch it !, si on est dans la condition launch_fvs ") 

82 from subprocess import Popen 

83 p = Popen(list_args_wss) 

84 

85 import time 

86 time.sleep(1) 

87 

88 self.map_live_streaming_websocket[port]["p"] = p 

89 

90 

91# ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) 

92# ssl_context.load_cert_chain(certfile=self.default_param.cert_args, keyfile=self.default_param.key_args) 

93# import functools 

94 

95# self.map_live_streaming_websocket[port]["loop_for_wss_server"] = loop_for_wss_server 

96# self.map_live_streaming_websocket[port]["start_server"] = start_server 

97 

98# loop_for_wss_server = asyncio.new_event_loop() 

99# start_server = websockets.serve(functools.partial(save_audio, lss=lss), 

100# self.default_param.hostname, 

101# port, ssl=ssl_context, 

102# loop = loop_for_wss_server) 

103 

104# asyncio.run(start_server) # - [ ] TODO VR 2-10-23 args to test server_stopped 

105# loop_for_wss_server.run_until_complete(start_server) # - [ ] TODO VR 2-10-23 args to test server_stopped 

106# loop_for_wss_server.run_forever() 

107 

108 return self.map_live_streaming_websocket[port] 

109 

110 def stop_web_socket(self, port, user_id): 

111 message = "default message shouldn't not be displayed" 

112 if port in self.map_live_streaming_websocket: 

113 message = " Asked to stop " + str(port) 

114 if user_id == self.map_live_streaming_websocket[port]["user_id"]: 

115 message += "We should stop" 

116 p = self.map_live_streaming_websocket[port]["p"] 

117 p.terminate() 

118# loop = self.map_live_streaming_websocket[port]["loop_for_wss_server"] 

119# loop.stop() 

120 

121# pending = asyncio.all_tasks(loop=loop) 

122# # Run loop until tasks done: 

123# if len(pending) == 0: 

124# loop.close() 

125# else : 

126# loop.run_until_complete(asyncio.gather(*pending)) 

127# print("Shutdown complete ...") 

128 

129 message +="Maybe we did ! or not !" 

130 self.map_live_streaming_websocket[port]["running"] = False 

131 self.map_live_streaming_websocket[port]["message"] = message 

132 return self.map_live_streaming_websocket[port] 

133 else : 

134 message +=" Incorrect user_id, we don't stop ! " 

135 return message 

136 else : 

137 message = " Websocket with port " + str(port) + " is not known so can't be stopped !" 

138 return message 

139 

140 def kill_all(self): 

141 message = "default message shouldn't not be displayed" 

142 for port in self.map_live_streaming_websocket: 

143 p = self.map_live_streaming_websocket[port]["p"] 

144 self.map_live_streaming_websocket[port]["running"] = False 

145 

146 return self.map_live_streaming_websocket 

147 

148 def list_all(self): 

149 return self.map_live_streaming_websocket 

150 

151class TranscriptJob(): 

152 def __init__(self): 

153 print("TODO") 

154 

155 

156 

157if not os.path.exists("temp"): 

158 os.makedirs("temp") 

159 

160 

161list_chunk_wav = {} 

162# TODO uses length_data size or time correctly 

163length_data = {"time":0, "size":0} 

164 

165# interval_stream_audio needs to be consistent with javascript ! grrr 

166params_live_stream = {"interval_stream_audio" : 3000, 

167 "duration_transcript" :6000} 

168 

169def get_info_thread(): 

170 global list_chunk_wav 

171 ret = str(list_chunk_wav.keys()) 

172 return ret 

173 

174import struct 

175import numpy as np 

176 

177rate = 44100 

178 

179def sine_samples(freq, dur): 

180 # Get (sample rate * duration) samples on X axis (between freq 

181 # occilations of 2pi) 

182 X = (2*np.pi*freq/rate) * np.arange(rate*dur) 

183 

184 # Get sine values for these X axis samples (as integers) 

185 S = (32767*np.sin(X)).astype(int) 

186 

187 # Pack integers as signed "short" integers (-32767 to 32767) 

188 as_packed_bytes = (map(lambda v:struct.pack('h',v), S)) 

189 return as_packed_bytes 

190 

191import base64 

192# TODO move in utils 

193def extract_from_to(in_file, time_start, time_end): 

194 from pydub import AudioSegment 

195 sound = AudioSegment.from_file(in_file) 

196 dst = in_file + ".extract.wav" 

197 out_format = "wav" 

198 

199 print("Exporting " + str(sound.duration_seconds)) 

200 print("While len is " + str(len(sound))) 

201 

202 frame_extract_start = int(time_start * len(sound) / (sound.duration_seconds * 1000)) 

203 frame_extract_end = int(time_end * len(sound) / (sound.duration_seconds * 1000)) 

204 

205 extract_sound = sound[frame_extract_start:frame_extract_end] 

206 print(" extract_sound duration_seconds : " + str(extract_sound.duration_seconds)) 

207 extract_sound.export(dst, format=out_format, bitrate="128k") 

208 

209 return dst 

210 

211 

212def write_to_file(data, begin_time_current_chunk, verbose=False, lss=None): 

213 global list_chunk_wav 

214# base64_audio = str(data)[34:].encode() 

215# decode_string = base64.b64decode(base64_audio) 

216 from uuid import uuid4 

217 export_wav = "temp/temp_"+ str(uuid4()).replace("-","_") + ".wav" 

218 wav_file = open(export_wav, "wb") 

219 

220 if params_live_stream["interval_stream_audio"] != params_live_stream["duration_transcript"]: 

221 

222 nb = int(params_live_stream["duration_transcript"] / params_live_stream["interval_stream_audio"]) 

223 

224 print(" find in " + str(list_chunk_wav.keys())) 

225 list_keys = list(list_chunk_wav.keys()) 

226 # TODO begin tient mal son nom 

227 index_begin = list_keys.index(begin_time_current_chunk) 

228 if index_begin == -1: 

229 wav_file.write(data) 

230 else : 

231 print(" En fait index_begin doit etre le dernier pour les premiers appel à ce bouzin : ") 

232 print(" index_begin : " + str(index_begin)) 

233 print(" len list_keys : " + str(len(list_keys))) 

234 

235 start_glissant = max(0, index_begin - nb) 

236 print(" start_glissant : " + str(start_glissant)) 

237 print(" Mais on part de 0, sorry ! ") 

238 start_glissant = 0 

239 

240 try : 

241 for i in range(start_glissant, index_begin): 

242 key_time_or_size = list_keys[i] 

243 print(" key_time_or_size : " + str(key_time_or_size)) 

244 wav_file.write(list_chunk_wav[key_time_or_size]) 

245 

246 wav_file.close() 

247 start_extract = int(max(0, index_begin - nb) * params_live_stream["interval_stream_audio"]) 

248 end_extract = start_extract + params_live_stream["duration_transcript"] 

249 res = extract_from_to(export_wav, start_extract, end_extract) 

250 

251 from lib.datou.datou_exec import datou_exec 

252 from auth.lib_auth import get_datou_exec_context_as_complete_param_json 

253 context_datou_exec_json = get_datou_exec_context_as_complete_param_json(verbose=verbose, 

254 privacy=False, lss=lss) 

255 

256 output, audit_json = datou_exec(["speech_to_text"], {"file":res}, context_datou_exec_json) 

257 return output 

258 

259 except Exception as e: 

260 print(str(e)) 

261 return "Error" 

262 

263 else: 

264 wav_file.write(data) 

265 return "Just one chunk, not transcribing it !" 

266 

267 wav_file.close() 

268# wav_file.write(decode_string) 

269 

270 

271 

272async def save_audio(websocket, path = "temp/live.wav", verbose=False, lss=None): 

273 global list_chunk_wav 

274 try: 

275 with wave.open(path, 'wb') as file: 

276# file.setparams((2, 2, rate, 0, 'NONE', 'not compressed')) 

277# frames = b''.join(sine_samples(freq, dur)) 

278 

279 file.setnchannels(1) 

280 file.setsampwidth(2) 

281# file.setframerate(48000) 

282# file.setframerate(8000) 

283 file.setframerate(44100) 

284# file.setframerate(8000) 

285# file.setparams() 

286 while True: 

287 data = await websocket.recv() 

288 if not data: 

289 break 

290 print(" data length : " + str(len(data))) 

291 print(" data length : " + str(data)[:100]) 

292 list_chunk_wav[length_data["time"]] = data 

293 print(" list_chunk_wav.keys() " + str(list_chunk_wav.keys())) 

294 

295 await websocket.send(str(list_chunk_wav.keys())) 

296 await websocket.send("DATA") 

297 await websocket.send(bytes(b"DATA")) 

298# await asyncio.sleep(1) 

299 

300 res = write_to_file(data, length_data["time"], verbose=verbose, lss=lss) 

301 return_json = str(str(res)) 

302 return_json = json.dumps(res) 

303 await websocket.send(return_json) 

304 length_data["time"] += len(data) 

305 

306 

307# base64_audio = str(data)[34:].encode() # [:-4].replace(" ", "+").encode() 

308# frames = base64.b64decode(base64_audio) 

309# file.writeframes(frames) 

310 

311# ca ca marche quand on arrete 

312# file.writeframes(data) 

313# file.close() 

314 except KeyboardInterrupt: 

315 print ('KeyboardInterrupt exception is caught with try') 

316 print(" list_chunk_wav.keys() " + str(list_chunk_wav.keys())) 

317 

318import signal 

319import sys 

320 

321def sigint_handler(signal, frame): 

322 print ('KeyboardInterrupt is caught') 

323 print(" list_chunk_wav.keys() " + str(list_chunk_wav.keys())) 

324 sys.exit(0) 

325 

326 

327# 192.168.10.105 

328def launch_ws(hostname = "0.0.0.0", port = 8080, lss = None, verbose = False, otp = None): 

329 if lss == None and otp != None: 

330 from server.safia import lpgss_singleton, lib_external_info_from_apia_at, lib_auth_now_from_at, lib_right_singleton 

331 from lib.lib_safia_system import LibSafiaSystem 

332 lss = LibSafiaSystem(lib_user_data_internal=lpgss_singleton, 

333 lib_user_data_external=lib_external_info_from_apia_at, 

334 lib_auth_user_otp=lib_auth_now_from_at, 

335 lib_right=lib_right_singleton) 

336 info, is_valid = lss.connect_with_otp(otp) 

337 

338 # UNCOMMENT LOCALHOST WSS 

339 cert_args = "/home/safia/.ssl/safia.app.crt" 

340 key_args = "/home/safia/.ssl/safia.app.key" 

341 

342 from auth.lib_conf_system import lcs_global_singleton 

343 

344 cert_args = lcs_global_singleton.get_cert_ssl() 

345 key_args = lcs_global_singleton.get_key_ssl() 

346 

347 # cert_args = "/Users/moilerat/Documents/Fotonower/Safia/prompt/doc/conf_install/autosigne/cert.pem" 

348# key_args = "/Users/moilerat/Documents/Fotonower/Safia/prompt/doc/conf_install/autosigne/key.pem" 

349 tuple_ssl_context = (cert_args, key_args) 

350 

351 import ssl, pathlib 

352 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) 

353 

354# ssl_context.load_cert_chain( 

355# certfile=pathlib.Path(__file__).with_name(cert_args), keyfile=pathlib.Path(__file__).with_name(key_args)) 

356 

357 ssl_context.load_cert_chain(certfile=cert_args, keyfile=key_args) 

358# ssl_context = None 

359 

360 import functools 

361 start_server = websockets.serve(functools.partial(save_audio, lss=lss), hostname, port, ssl = ssl_context) 

362 

363# 

364 # start_server = websockets.serve( 

365 # functools.partial(hello, parent_conn=parent_conn), 

366 # '127.0.0.1', 8765) 

367 

368# on_message = on_message, 

369 # on_error = on_error, 

370 # on_close = on_close) 

371 

372# import ssl 

373 

374# websocket.enableTrace(True) 

375# ws = websocket.WebSocketApp("wss://stream.binance.com:9443/ws/bnbbtc@ticker", 

376# on_message=on_message, 

377# on_error=on_error, 

378# on_close=on_close) 

379# ws.on_open = on_open 

380# ws.run_forever() 

381# ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE}) 

382 # , ssl=ssl.SSLContext() 

383 # https://github.com/python-websockets/websockets/issues/419 

384 

385 asyncio.get_event_loop().run_until_complete(start_server) 

386 asyncio.get_event_loop().run_forever() 

387 

388 signal.signal(signal.SIGINT, sigint_handler) 

389 

390 

391 

392if __name__ == "__main__": 

393 import sys 

394 print("sys.argv : ") 

395 print(sys.argv) 

396 print(" len(sys.argv) : ") 

397 print(len(sys.argv)) 

398 if len(sys.argv) > 1: 

399 port = sys.argv[1] 

400 print(" port : " + str(port)) 

401 else: 

402 port = 5050 

403 if len(sys.argv) > 2: 

404 otp = sys.argv[2] 

405 else: 

406 otp = None 

407 launch_ws(port= port, otp = otp) 

408# sans cela bug etrange 

409# RuntimeError: There is no current event loop in thread 'Thread-26 (process_request_thread)'. 

410 

411#try: 

412# x = input() 

413# print ('Try using KeyboardInterrupt') 

414#except KeyboardInterrupt: 

415# print ('KeyboardInterrupt exception is caught') 

416#else: 

417# print ('No exceptions are caught')