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
« prev ^ index » next coverage.py v7.9.1, created at 2026-01-26 23:58 +0100
1import asyncio
2import datetime
3import json
5import websockets
6import wave
7import os
8import ssl
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
17 from auth.lib_conf_system import lcs_global_singleton
19 if cert_args != None:
20 self.cert_args = cert_args
21 else :
22 self.cert_args = lcs_global_singleton.get_cert_ssl()
24 if key_args != None:
25 self.key_args = key_args
26 else :
27 self.key_args = lcs_global_singleton.get_key_ssl()
29 self.hostname = "0.0.0.0"
31# DEV TO TEST
32def server_stopped(websocket):
33 print(" We are here since a server was stopped !")
35class WebSocketAllocator():
36 def __init__(self):
37 self.map_live_streaming_websocket = {}
38 self.default_param = WebSocketLiveTranscriptParam()
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
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()
52 if user_id == None:
53 user_id = lss.get_user_id()
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}
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"
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 + " &")
73# os.system(command)
75 self.map_live_streaming_websocket[port]["running"] = True
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)
85 import time
86 time.sleep(1)
88 self.map_live_streaming_websocket[port]["p"] = p
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
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
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)
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()
108 return self.map_live_streaming_websocket[port]
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()
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 ...")
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
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
146 return self.map_live_streaming_websocket
148 def list_all(self):
149 return self.map_live_streaming_websocket
151class TranscriptJob():
152 def __init__(self):
153 print("TODO")
157if not os.path.exists("temp"):
158 os.makedirs("temp")
161list_chunk_wav = {}
162# TODO uses length_data size or time correctly
163length_data = {"time":0, "size":0}
165# interval_stream_audio needs to be consistent with javascript ! grrr
166params_live_stream = {"interval_stream_audio" : 3000,
167 "duration_transcript" :6000}
169def get_info_thread():
170 global list_chunk_wav
171 ret = str(list_chunk_wav.keys())
172 return ret
174import struct
175import numpy as np
177rate = 44100
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)
184 # Get sine values for these X axis samples (as integers)
185 S = (32767*np.sin(X)).astype(int)
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
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"
199 print("Exporting " + str(sound.duration_seconds))
200 print("While len is " + str(len(sound)))
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))
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")
209 return dst
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")
220 if params_live_stream["interval_stream_audio"] != params_live_stream["duration_transcript"]:
222 nb = int(params_live_stream["duration_transcript"] / params_live_stream["interval_stream_audio"])
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)))
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
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])
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)
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)
256 output, audit_json = datou_exec(["speech_to_text"], {"file":res}, context_datou_exec_json)
257 return output
259 except Exception as e:
260 print(str(e))
261 return "Error"
263 else:
264 wav_file.write(data)
265 return "Just one chunk, not transcribing it !"
267 wav_file.close()
268# wav_file.write(decode_string)
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))
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()))
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)
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)
307# base64_audio = str(data)[34:].encode() # [:-4].replace(" ", "+").encode()
308# frames = base64.b64decode(base64_audio)
309# file.writeframes(frames)
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()))
318import signal
319import sys
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)
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)
338 # UNCOMMENT LOCALHOST WSS
339 cert_args = "/home/safia/.ssl/safia.app.crt"
340 key_args = "/home/safia/.ssl/safia.app.key"
342 from auth.lib_conf_system import lcs_global_singleton
344 cert_args = lcs_global_singleton.get_cert_ssl()
345 key_args = lcs_global_singleton.get_key_ssl()
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)
351 import ssl, pathlib
352 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
354# ssl_context.load_cert_chain(
355# certfile=pathlib.Path(__file__).with_name(cert_args), keyfile=pathlib.Path(__file__).with_name(key_args))
357 ssl_context.load_cert_chain(certfile=cert_args, keyfile=key_args)
358# ssl_context = None
360 import functools
361 start_server = websockets.serve(functools.partial(save_audio, lss=lss), hostname, port, ssl = ssl_context)
363#
364 # start_server = websockets.serve(
365 # functools.partial(hello, parent_conn=parent_conn),
366 # '127.0.0.1', 8765)
368# on_message = on_message,
369 # on_error = on_error,
370 # on_close = on_close)
372# import ssl
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
385 asyncio.get_event_loop().run_until_complete(start_server)
386 asyncio.get_event_loop().run_forever()
388 signal.signal(signal.SIGINT, sigint_handler)
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)'.
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')