def setup_socketio(app: web.Application): # SEE https://github.com/miguelgrinberg/python-socketio/blob/v4.6.1/docs/server.rst#aiohttp # TODO: ujson to speed up? # TODO: client_manager= to socketio.AsyncRedisManager/AsyncAioPikaManager for horizontal scaling (shared sessions) sio = AsyncServer(async_mode="aiohttp", logger=log, engineio_logger=False) sio.attach(app) app[APP_CLIENT_SOCKET_SERVER_KEY] = sio handlers_utils.register_handlers(app, handlers)
def setup_socketio(app: web.Application): # ---------------------------------------------- # TODO: temporary, just to check compatibility between # trafaret and pydantic schemas assert_valid_config(app) # --------------------------------------------- mgr = None sio = AsyncServer(async_mode="aiohttp", client_manager=mgr, logging=log) sio.attach(app) app[APP_CLIENT_SOCKET_SERVER_KEY] = sio handlers_utils.register_handlers(app, handlers)
def aiohttp_server(self): sio = AsyncServer(async_mode="aiohttp") @sio.on(EVENT_USER_UTTERED) async def on_user_uttered(session_id: str, request: Any): if self.bot_messages_stack: messages = self.bot_messages_stack.pop(0) for message in messages: await sio.emit(EVENT_BOT_UTTERED, message, room=session_id) app = web.Application() sio.attach(app) runner = web.AppRunner(app) return runner
async def api_server( game_app: game.GameApp, sio: AsyncServer, player_ranking_repository: PlayerRankingRepository) -> web.AppRunner: app = web.Application() sio.attach(app) logging.basicConfig(level=logging.DEBUG) setup_routes(app, sio, game_app, player_ranking_repository) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, "0.0.0.0", 8080) await site.start() return runner
def blueprint( self, on_new_message: Callable[[UserMessage], Awaitable[Any]] ) -> Blueprint: # Workaround so that socketio works with requests from other origins. # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183 sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[]) socketio_webhook = SocketBlueprint( sio, self.socketio_path, "socketio_webhook", __name__ ) # make sio object static to use in get_output_channel self.sio = sio @socketio_webhook.route("/", methods=["GET"]) async def health(_: Request) -> HTTPResponse: return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid: Text, _) -> None: logger.debug(f"User {sid} connected to socketIO endpoint.") @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid: Text) -> None: logger.debug(f"User {sid} disconnected from socketIO endpoint.") @sio.on("session_request", namespace=self.namespace) async def session_request(sid: Text, data: Optional[Dict]): if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex if self.session_persistence: sio.enter_room(sid, data["session_id"]) await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug(f"User {sid} connected to socketIO endpoint.") @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid: Text, data: Dict) -> Any: output_channel = SocketIOOutput(sio, self.bot_message_evt) if self.session_persistence: if not data.get("session_id"): raise_warning( "A message without a valid session_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event." ) return sender_id = data["session_id"] else: sender_id = sid message = UserMessage( data["message"], output_channel, sender_id, input_channel=self.name() ) await on_new_message(message) return socketio_webhook
async def start(self): global sio sio = AsyncServer(async_mode='aiohttp') self.sio = sio @sio.event async def connect(sid, environ): global client_sid client_sid = sid await sio.emit('response', {'type': 'response'}) self.enable_sync() sio.attach(self.app, socketio_path='ws') self.runner = web.AppRunner(self.app) await self.runner.setup() site = web.TCPSite(self.runner, 'localhost', 8080) await site.start()
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic") socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) print('Connected!') @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): print('This is sessioin request') if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketIO endpoint." "".format(sid)) @sio.on('user_uttered', namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt, data['message']) if data['message'] == "/get_started": message = data['message'] else: ##receive audio received_file = 'output_' + sid + '.wav' urllib.request.urlretrieve(data['message'], received_file) path = os.path.dirname(__file__) fs, audio = wav.read("output_{0}.wav".format(sid)) message = ds.stt(audio, fs) await sio.emit(self.user_message_evt, {"text": message}, room=sid) message_rasa = UserMessage(message, output_channel, sid, input_channel=self.name()) await on_new_message(message_rasa) return socketio_webhook
def blueprint(self, on_new_message=()): sio = AsyncServer(async_mode="sanic") socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) print('Connected!') @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): print('This is sessioin request') if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketIO endpoint." "".format(sid)) @sio.on('uservoice_uttered', namespace=self.namespace) async def handle_message(sid, data): logger.debug("reached here with data") output_channel = SocketIOOutput(sio, sid, self.bot_message_evt, data['message']) if data['message'] == "/get_started": message = data['message'] else: ##receive audio if data["isSpeech"] == True: message = self.StFun(data['message']) else: message = self.TsFun(data['message']) await sio.emit(self.bot_message_evt, message, room=sid) if message != "": # send request to the bot pass # message_rasa = UserMessage(message, output_channel, sid, # input_channel=self.name()) # await on_new_message(message_rasa) return socketio_webhook
def main() -> None: sio = AsyncServer(cors_allowed_origins='*') database = Database('data.db') player_ranking_repository = PlayerRankingRepository(database) ranking_system = RankingSystem(player_ranking_repository) game_app = GameApp() game_app.on_game_result = ranking_system.calculate_ranking_points loop = asyncio.get_event_loop() loop.create_task(api_server(game_app, sio, player_ranking_repository)) loop.run_until_complete(game_app.start_games()) loop.close()
def blueprint(self, on_new_message): # Workaround so that socketio works with requests from other origins. # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183 sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[]) socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=["GET"]) async def health(request: Request): return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid): logger.debug( "User {} disconnected from socketIO endpoint.".format(sid)) @sio.on("session_request", namespace=self.namespace) async def session_request(sid, data): if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt) if self.session_persistence: if not data.get("session_id"): logger.warning("A message without a valid sender_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event.") return sender_id = data["session_id"] else: sender_id = sid message = UserMessage(data["message"], output_channel, sender_id, input_channel=self.name(), metadata=data['customData']) await on_new_message(message) return socketio_webhook
def blueprint(self, on_new_message): sio = AsyncServer(async_mode='sanic') socketio_webhook = SocketBlueprint(sio, self.socketio_path, 'socketio_webhook', __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketIO endpoint." "".format(sid)) @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt) if self.session_persistence: if not data.get("session_id"): logger.warning("A message without a valid sender_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event.") return sender_id = data['session_id'] else: sender_id = sid message = UserMessage(data['message'], output_channel, sender_id, input_channel=self.name()) await on_new_message(message) return socketio_webhook
def run(self): global sio global app if sio: return sio = AsyncServer(async_mode='sanic', cors_allowed_origins=[], allow_upgrades=True, transports=['websocket'], ping_interval=15, ping_timeout=25, engineio_logger=False) app = Sanic() sio.attach(app) @sio.on('funenc_socketio_client_msg') def mdias_event(sid, data): _logger.debug( "get mdias msg: {data} with sid {sid}".format(data=data, sid=sid)) return model_env.deal_event(sid, data) @sio.event async def connect(sid, environ): return model_env.deal_user_connect(sid, environ) @sio.event async def disconnect(sid): model_env.deal_user_disconnect(sid) # 必需放在服务线程中, 否则会报utf8错误 threading.Thread(target=self.start_client_event).start() port = 9080 app.config['CORS_SUPPORTS_CREDENTIALS'] = True host = config['socket_io_host'] or '0.0.0.0' app.run(host=host, port=port, register_sys_signals=False)
def ws_init(): global SIO SIO = AsyncServer(async_mode='tornado', logger=False, engineio_logger=None) # see https://github.com/miguelgrinberg/python-socketio/blob/master/examples/server/tornado/app.py SIO.register_namespace(ChatNamespace('/chat')) # See https://python-socketio.readthedocs.io/en/latest/server.html#namespaces if get_config().max_miners > 0: # Only register pool namespace if we want to run a pool SIO.register_namespace(PoolNamespace('/pool'))
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic") socketio_webhook = SocketBlueprint(sio, self.socketio_path, 'socketio_webhook', __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request: Request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketio endpoint.".format(sid)) @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketio endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketio endpoint." "".format(sid)) @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid, data): output_channel = WebchatOutput(sio, sid, self.bot_message_evt) if self.session_persistence and ("session_id" not in data or data["session_id"] is None): logger.debug("A message without a valid sender_id was received") else: if 'customData' in data: output_channel.set_custom_data(data['customData']) if 'language' in data['customData']: output_channel.set_language(data['customData']['language']) sender_id = data['session_id'] if self.session_persistence else sid message = UserMessage(data['message'], output_channel, sender_id, input_channel=self.name()) await on_new_message(message) return socketio_webhook
def blueprint( self, on_new_message: Callable[[UserMessage], Awaitable[Any]]) -> Blueprint: # Workaround so that socketio works with requests from other origins. # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183 sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[]) socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) # make sio object static to use in get_output_channel self.sio = sio """fatta da me""" @sio.on('my_event', namespace=self.namespace) async def ciallo(sid: Text, _) -> None: logger.debug("ho trovato un messaggio ciallo") @socketio_webhook.route("/", methods=["GET"]) async def health(_: Request) -> HTTPResponse: return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid: Text, data: Dict) -> None: logger.debug(f"User {sid} connected to socketIO endpoint.") logger.debug("mi sono connesso") logger.debug(data) global user_ID if ("io=" + user_ID == data["HTTP_COOKIE"]): logger.debug("we1") sid = user_ID else: user_ID = sid logger.debug(user_ID) logger.debug("Ho ricevuto richiesta di sessione") logger.debug(data["HTTP_COOKIE"]) if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex if self.session_persistence: sio.enter_room(sid, data["session_id"]) await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug(f"User {sid} session requested to socketIO endpoint.") if (tracker == True): data = {} data['names'] = [] data['names'].append({ 'sender': 'bot', 'message': 'What data are you looking for?', }) with open("sessions/" + sid + ".json", "w") as f: json.dump(data, f) await self.sio.emit( 'json_response', { "type": "message", "payload": { "sender": "bot", "text": "What data are you looking for?" } }) await self.sio.emit( 'json_response', { "type": "available_choices", "payload": { "showSearchBar": False, "showDetails": False, "caption": 'Data available', "showHelpIcon": False, "elements": [{ 'name': 'Annotations', 'value': 'Annotations' }, { 'name': 'Experiments', 'value': 'Experiments' }] } }) await self.sio.emit('json_response', { "type": "workflow", "payload": { "state": "Data Selection" } }) @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid: Text) -> None: logger.debug(f"User {sid} disconnected from socketIO endpoint.") @sio.on("reconnect", namespace=self.namespace) async def reconnect(sid: Text) -> None: print("i'm back online") logger.debug(" i'm back") @sio.on("session_request", namespace=self.namespace) async def session_request(sid: Text, data: Optional[Dict]): logger.debug("Ho ricevuto richiesta di sessione") if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex if self.session_persistence: sio.enter_room(sid, data["session_id"]) await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug("User {sid} session requested to socketIO endpoint.") @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid: Text, data: Dict) -> Any: output_channel = SocketIOOutput(sio, self.bot_message_evt) if self.session_persistence: if not data.get("session_id"): rasa.shared.utils.io.raise_warning( "A message without a valid session_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event.") return sender_id = data["session_id"] else: sender_id = sid message = UserMessage(data["message"], output_channel, sender_id, input_channel=self.name()) await on_new_message(message) """fatta da me da é questo che funziona veramente""" @sio.on('my_event', namespace=self.namespace) async def handle_message(sid: Text, data: Dict) -> Any: output_channel = SocketIOOutput(sio, self.bot_message_evt) logger.debug("ho preso un messaggio fatto da me rimuovere 1") global user_ID message = UserMessage(data["data"], output_channel, user_ID, input_channel=self.name()) print('data[data]', data["data"]) with open('data.txt', 'a') as outfile: json.dump(data["data"] + '\n', outfile) if (tracker == True): with open("sessions/" + user_ID + ".json") as json_file: data2 = json.load(json_file) temp = data2['names'] y = {"sender": user_ID, 'message': data["data"]} temp.append(y) write_json(data2, "sessions/" + user_ID + ".json") await on_new_message(message) return socketio_webhook
from socketio import AsyncServer sio = AsyncServer(async_mode="sanic") socketio_webhook = SocketBlueprint( sio, self.socketio_path, "socketio_webhook", __name__ )
import uuid from socketio import AsyncServer from sanic.log import logger from slack_integration import SlackIntegration, session_to_channel session_to_sid = {} ERROR_CONNECT_TO_SLACK = "Could not connect to operator" ERROR_SEND_MESSAGE = "Could not send message" sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[]) # '*' conn = SlackIntegration() @sio.on("connect") async def connect(sid, environ): logger.info(f"User {sid} connected to socketIO endpoint.") @sio.on("disconnect") async def disconnect(sid): logger.info(f"User {sid} disconnected from socketIO endpoint.") @sio.on("session_request") async def session_request(sid, data): if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex
def async_server(self, container): engineio_options = container('config', namespace=self.namespace) return AsyncServer(**engineio_options)
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic", logger=True, cors_allowed_origins='*') socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect') async def connect(sid, environ): print("User {} connected to socketIO endpoint.".format(sid)) @sio.on('disconnect') async def disconnect(sid): print("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request') async def session_request(sid, data): print('Session request received') if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) print("User {} connected to socketIO endpoint." "".format(sid)) @sio.on('user_uttered') async def handle_message(sid, data): print('User uttered') output_channel = SocketIOOutput(sio, sid, self.bot_message_evt, data['message']) if data['message'] == "/get_started": message = data['message'] else: ##receive audio received_file = 'output_' + sid + '.wav' request.urlretrieve(data['message'], received_file) # fs, audio = wav.read("output_{0}.wav".format(sid)) input_audio_file = wave.open("output_{0}.wav".format(sid), 'rb') converted_audio_to_bytes = numpy.frombuffer( input_audio_file.readframes(input_audio_file.getnframes()), numpy.int16) input_audio_file.close() message = self.speech_to_text_model.stt( converted_audio_to_bytes) insert_user_message_to_database(message, sid) await sio.emit(self.user_message_evt, {"text": message}, room=sid) message_rasa = UserMessage(message, output_channel, sid, input_channel=self.name()) await on_new_message(message_rasa) return socketio_webhook
from socketio import AsyncServer from aiohttp import web from aiohttp_session import get_session, setup from aiohttp_session.cookie_storage import EncryptedCookieStorage from hashlib import sha3_512 from redis import Redis import pickle database = Redis(host='localhost', port=6379, db=0) app = web.Application() setup(app, EncryptedCookieStorage(b'ghnrty1twoo7234th66ytewtke3arer&')) sio = AsyncServer(async_mode='aiohttp') sio.attach(app) routes = web.RouteTableDef() @routes.get("/") async def index_route(request): with open('index.html', 'rb') as file: index = file.read() return web.Response(body=index, content_type="text/html") @routes.post("/app") async def app_route(request): session = await get_session(request) data = await request.post() if 'secret' in data: code = sha3_512()
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic") socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) print('Connected!') @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): print('This is sessioin request') #print(data) #print(data['session_id']) if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketIO endpoint." "".format(sid)) #@sio.on('recorder stopped', namespace=self.namespace) #async def get_audio(sid, data): # print('This is what I got') # print(data) @sio.on('user_uttered', namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt, data['message']) if data['message'] == "/get_started": message = data['message'] else: ##receive audio as .ogg received_file = sid + '.wav' urllib.request.urlretrieve(data['message'], received_file) path = os.path.dirname(__file__) #print(path) #print(sid) # convert .ogg file into int16 wave file by ffmpeg #-ar 44100 os.system("ffmpeg -y -i {0} -ar 16000 output_{1}.wav".format( received_file, sid)) #os.system("ffmpeg -y -i {0} -c:a pcm_s161e output_{1}.wav".format(received_file,sid)) N_FEATURES = 25 N_CONTEXT = 9 BEAM_WIDTH = 500 LM_ALPHA = 0.75 LM_BETA = 1.85 ds = Model('deepspeech-0.5.1-models/output_graph.pbmm', N_FEATURES, N_CONTEXT, 'deepspeech-0.5.1-models/alphabet.txt', BEAM_WIDTH) fs, audio = wav.read("output_{0}.wav".format(sid)) message = ds.stt(audio, fs) #await self.sio.emit(self.bot_message_evt, response, room=socket_id) await sio.emit("user_uttered", {"text": message}, room=sid) #ffmpeg -i input.flv -f s16le -acodec pcm_s16le output.raw if self.session_persistence: #if not data.get("session_id"): # logger.warning("A message without a valid sender_id " # "was received. This message will be " # "ignored. Make sure to set a proper " # "session id using the " # "`session_request` socketIO event.") # return #sender_id = data['session_id'] #else: sender_id = sid message_rasa = UserMessage(message, output_channel, sender_id, input_channel=self.name()) await on_new_message(message_rasa) return socketio_webhook
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic", cors_allowed_origins=self.cors_allowed_origins) socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=["GET"]) async def health(request: Request): return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid, environ): ip = environ['REMOTE_ADDR'] or environ['HTTP_X_FORWARDED_FOR'] self.remote_addr = ip self.c = MyUtils.get_record_db_cursor() logger.debug( "User {} (from {}) connected to socketIO endpoint.".format( sid, ip)) @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid): self.c.connection.close() logger.debug( "User {} disconnected from socketIO endpoint.".format(sid)) @sio.on("session_request", namespace=self.namespace) async def session_request(sid, data): if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt) logger.debug("Received data: {} ".format(data)) if self.session_persistence: if not data.get("session_id"): logger.warning("A message without a valid sender_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event.") return sender_id = data["session_id"] else: sender_id = sid message = UserMessage(data["message"], output_channel, sender_id, input_channel=self.name()) if data["message"][0] != '/': query = """insert into message_received (from_user_id, session_id, content, `when`, ip_address) values (%s, %s, %s, %s, %s)""" self.c.execute( query, (data["customData"]["from_user_id"], data["session_id"], data["message"], time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), self.remote_addr)) self.c.connection.commit() await on_new_message(message) return socketio_webhook
def blueprint( self, on_new_message: Callable[[UserMessage], Awaitable[Any]] ) -> Blueprint: # Workaround so that socketio works with requests from other origins. # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183 sio = AsyncServer( async_mode="sanic", cors_allowed_origins=self.cors_allowed_origins ) socketio_webhook = SocketBlueprint( sio, self.socketio_path, "socketio_webhook", __name__ ) # make sio object static to use in get_output_channel self.sio = sio @socketio_webhook.route("/", methods=["GET"]) async def health(_: Request) -> HTTPResponse: return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid: Text, _) -> None: logger.debug(f"User {sid} connected to socketIO endpoint.") @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid: Text) -> None: logger.debug(f"User {sid} disconnected from socketIO endpoint.") @sio.on("session_request", namespace=self.namespace) async def session_request(sid: Text, data: Optional[Dict]): props = {} if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex if self.session_persistence: sio.enter_room(sid, data["session_id"]) if self.config is not None: props = self.config else: config = await get_config_via_graphql( os.environ.get("BF_URL"), os.environ.get("BF_PROJECT_ID") ) if config and "credentials" in config: credentials = config.get("credentials", {}) channel = credentials.get("rasa_addons.core.channels.webchat_plus.WebchatPlusInput") if channel is None: channel = credentials.get("rasa_addons.core.channels.WebchatPlusInput") if channel is None: channel = credentials.get("rasa_addons.core.channels.webchat.WebchatInput") if channel is None: channel = credentials.get("rasa_addons.core.channels.WebchatInput", {}) props = channel.get("props", {}) await sio.emit( "session_confirm", {"session_id": data["session_id"], "props": props}, room=sid, ) logger.debug(f"User {sid} connected to socketIO endpoint.") @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid: Text, data: Dict) -> Any: output_channel = WebchatOutput(sio, self.bot_message_evt) if self.session_persistence: if not data.get("session_id"): warnings.warn( "A message without a valid sender_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event." ) return sender_id = data["session_id"] else: sender_id = sid message = UserMessage( data["message"], output_channel, sender_id, input_channel=self.name(), metadata=self.get_metadata(data), ) await on_new_message(message) return socketio_webhook
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic") socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) from tinydb import TinyDB, Query import message_handler db_users = TinyDB('db_users.json') User = Query() @socketio_webhook.route("/", methods=["GET"]) async def health(request: Request): return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid): logger.debug( "User {} disconnected from socketIO endpoint.".format(sid)) @sio.on("session_request", namespace=self.namespace) async def session_request(sid, data): print("request made to connect") print(data) if data is None: data = {} if "session_id" not in data or data["session_id"] is None: print("creation d'un session id") data["session_id"] = uuid.uuid4().hex await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt) print(data) #await output_channel._send_message(sid,{"text": "__ /!\ Enter the passphrase to use the chatbot :__"}) #await message_handler.handle_message(data, db_users, db_users.search(User.userName == data['customData']['userName']), output_channel, sid) ''' if( data["message"] == "%/get_started"): message = {"text": "__Welcome to the chatbot testing page, please enter provided passphrase to access functionalities__", "quick_replies": []} message["quick_replies"].append({ "content_type": "text", "title": "English", "payload": "/English", }) message["quick_replies"].append({ "content_type": "text", "title": "French", "payload": "/French", }) # await output_channel._send_message(sid,message) else: await output_channel._send_message(sid,{"text": "__ /!\ Enter the passphrase to use the chatbot :__"})''' if self.session_persistence: if not data.get("session_id"): logger.warning("A message without a valid sender_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event.") return sender_id = data["session_id"] else: sender_id = sid logger.info("message reçu") message = UserMessage(data["message"], output_channel, sender_id, input_channel=self.name()) await on_new_message(message) print(message) return socketio_webhook
from aiohttp import web from socketio import AsyncServer import json import os import time from threading import Thread import constants as c import UsrDefClasses import StateMachines as sM # ------------------------------------------------ # Variables # ------------------------------------------------ sio = AsyncServer() app = web.Application() sio.attach(app) AudioCtrl = UsrDefClasses.AudioControls() PowerCtrl = UsrDefClasses.PowerControls() MediaCtrl = UsrDefClasses.MediaControls() NAS = UsrDefClasses.Nas() StateMachine = sM.StateMachine(PowerCtrl, AudioCtrl, MediaCtrl) appRoutes = c.ROUTES iNetRadioJson = list() link = c.DEFAULTAUDIOFILE title = c.DEFAULTAUDIOTITLE # ------------------------------------------------ # Functions/ events # ------------------------------------------------
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic", cors_allowed_origins="*") socketio_webhook = SocketBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) print('Connected!') def read_wav_file(self, fileName): with wave.open(fileName, 'rb') as w: rate = w.getframerate() frames = w.getnframes() buffer = w.readframes(frames) print(rate) print(frames) return buffer, rate @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): print('This is sessioin request') if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketIO endpoint." "".format(sid)) def speech_to_text(WAVE_OUTPUT_FILENAME): r = sr.Recognizer() # open the file with sr.AudioFile(WAVE_OUTPUT_FILENAME) as source: # listen for the data (load audio to memory) audio_data = r.record(source) # recognize (convert from speech to text) text = r.recognize_google(audio_data) return text @sio.on('user_uttered', namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt, data['message']) if data['message'] == "/get_started": message = data['message'] else: ##receive audio received_file = 'output_' + sid + '.wav' urllib.request.urlretrieve(data['message'], received_file) message = speech_to_text(received_file) await sio.emit(self.user_message_evt, {"text": message}, room=sid) message_rasa = UserMessage(message, output_channel, sid, input_channel=self.name()) await on_new_message(message_rasa) return socketio_webhook
def blueprint(self, on_new_message): sio = AsyncServer(async_mode="sanic", cors_allowed_origins='*') socketio_webhook = SocketBlueprint( sio, self.socketio_path, "socketio_webhook", __name__ ) @socketio_webhook.route("/", methods=['GET']) async def health(request): return response.json({"status": "ok"}) @sio.on('connect', namespace=self.namespace) async def connect(sid, environ): logger.debug("User {} connected to socketIO endpoint.".format(sid)) @sio.on('disconnect', namespace=self.namespace) async def disconnect(sid): logger.debug("User {} disconnected from socketIO endpoint." "".format(sid)) @sio.on('session_request', namespace=self.namespace) async def session_request(sid, data): if data is None: data = {} if 'session_id' not in data or data['session_id'] is None: data['session_id'] = uuid.uuid4().hex await sio.emit("session_confirm", data['session_id'], room=sid) logger.debug("User {} connected to socketIO endpoint." "".format(sid)) @sio.on('user_uttered', namespace=self.namespace) async def handle_message(sid, data): output_channel = SocketIOOutput(sio, sid, self.bot_message_evt, data['message']) if data['message'].startswith("data:audio"): try: # message is an audio file received_file = 'output_rune.wav' audiopath = get_path_from_filename(received_file) logger.info(audiopath) urllib.request.urlretrieve(data['message'], audiopath) import os.path if not os.path.isfile(audiopath): raise Exception if USE_STT: message = generate_text(received_file, method=USE_STT) else: message = "Speech to Text isn't available" logger.info('STT ({}): {}'.format(USE_STT, message)) except Exception as e: # message is a string logger.error(e) message = None else: message = data["message"].lower() logger.info('TXT: {}'.format(message)) if message is not None: await sio.emit(self.user_message_evt, {"text": message.casefold()}, room=sid) message_rasa = UserMessage(message, output_channel, sid, input_channel=self.name()) await on_new_message(message_rasa) else: await sio.emit(self.bot_message_evt, {'text': "Dude, I can't hear shit, could you try speaking English?", 'link': None}, room=sid) return socketio_webhook
def blueprint( self, on_new_message: Callable[[UserMessage], Awaitable[Any]]) -> Blueprint: # Workaround so that socketio works with requests from other origins. # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183 sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[]) socketio_webhook = SocketVoiceBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) # make sio object static to use in get_output_channel self.sio = sio @socketio_webhook.route("/", methods=["GET"]) async def health(_: Request) -> HTTPResponse: return response.json({"status": "ok"}) @sio.on("connect", namespace=self.namespace) async def connect(sid: Text, _) -> None: logger.debug(f"User {sid} connected to socketIO endpoint.") @sio.on("disconnect", namespace=self.namespace) async def disconnect(sid: Text) -> None: logger.debug(f"User {sid} disconnected from socketIO endpoint.") @sio.on("session_request", namespace=self.namespace) async def session_request(sid: Text, data: Optional[Dict]): if data is None: data = {} if "session_id" not in data or data["session_id"] is None: data["session_id"] = uuid.uuid4().hex if self.session_persistence: sio.enter_room(sid, data["session_id"]) await sio.emit("session_confirm", data["session_id"], room=sid) logger.debug(f"User {sid} connected to socketIO endpoint.") @sio.on(self.user_message_evt, namespace=self.namespace) async def handle_message(sid: Text, data: Dict) -> Any: output_channel = SocketIOVoiceOutput(sio, self.bot_message_evt, self.botium_speech_url, self.botium_speech_apikey, self.botium_speech_language, self.botium_speech_voice) if self.session_persistence: if not data.get("session_id"): rasa.shared.utils.io.raise_warning( "A message without a valid session_id " "was received. This message will be " "ignored. Make sure to set a proper " "session id using the " "`session_request` socketIO event.") return sender_id = data["session_id"] else: sender_id = sid if data['message'].startswith('data:'): header, encoded = data['message'].split(",", 1) audioData = base64.b64decode(encoded.encode('ascii')) convertEndpoint = f"{self.botium_speech_url}/api/convert/WAVTOMONOWAV" logger.debug( f"handle_message - Calling Convert Endpoint: {convertEndpoint}" ) res = urlopen( Request(url=convertEndpoint, data=audioData, method='POST', headers={'content-type': 'audio/wav'})) audioDataWav = res.read() #with open('decoded_image.wav', 'wb') as file_to_save: # file_to_save.write(audioData) audioEndpoint = f"{self.botium_speech_url}/api/stt/{self.botium_speech_language}" logger.debug( f"handle_message - Calling Speech Endpoint: {audioEndpoint}" ) res = urlopen( Request(url=audioEndpoint, data=audioDataWav, method='POST', headers={'content-type': 'audio/wav'})) resJson = json.loads(res.read().decode('utf-8')) logger.debug( f"handle_message - Calling Speech Endpoint: {audioEndpoint} => {resJson}" ) message = resJson["text"] await sio.emit(self.user_message_evt, {"text": message}, room=sid) else: message = data['message'] message = UserMessage(message, output_channel, sender_id, input_channel=self.name()) await on_new_message(message) return socketio_webhook
except HTTPException: await self.disconnect(sid, namespace=self.namespace) print("##### HTTPException ######") except ValidationError: await self.emit(socket_events.server_error, ServerResponse(message="packet validation error", type="validation_error").dict(), room=sid) print("##### ValidationError ######") except: await self.emit(socket_events.server_error, ServerResponse(message="something went wrong", type="error").dict(), room=sid) print("##### General Error ######") sio = AsyncServer(async_mode='asgi') sio.register_namespace(ChatNameSpace('/chat')) socket_app = ASGIApp(sio) @sio.on("my event") async def my_event(sid, data): print("*#*#*#*#*#*") class HeadersModel(BaseModel): HTTP_TOKEN: str def get_headers(data: tuple) -> HeadersModel: data: dict = data[0]
'VOL-L-L': 'e', 'VOL-L-R': 'r', 'VOL-R-L': 'i', 'VOL-R-R': 'o' } import asyncio from sanic import Sanic from sanic_jinja2 import SanicJinja2 from socketio import AsyncServer from datetime import datetime from time import mktime import pyautogui pyautogui.FAILSAFE = False sio = AsyncServer(async_mode='sanic') app = Sanic(__name__) sio.attach(app) jinja = SanicJinja2(app) def millis_interval(start, end): """start and end are datetime instances""" diff = end - start millis = diff.days * 24 * 60 * 60 * 1000 millis += diff.seconds * 1000 millis += diff.microseconds / 1000 return millis @app.route('/')