Update backend/main.py

backend/main.py

@@ -7,33 +7,12 @@ from urllib import parse
 from uuid import uuid4
 import logging
 from fastapi.logger import logger as fastapi_logger
-
-###############################################
-# Configure logger
-
-logging.basicConfig(filename="output.log",
-                    filemode='w',
-                    format='%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s',
-                    datefmt='%H:%M:%S',
-                    level=logging.DEBUG)
-
-gunicorn_error_logger = logging.getLogger("gunicorn.error")
-gunicorn_logger = logging.getLogger("gunicorn")
-uvicorn_access_logger = logging.getLogger("uvicorn.access")
-uvicorn_access_logger.handlers = gunicorn_error_logger.handlers
-
-fastapi_logger.handlers = gunicorn_error_logger.handlers
-
-logger = logging.getLogger("socketio_server_pubsub")
-logger.propagate = True
-
-###############################################
-
 import sys
 # sys.path.append('/Users/benolojo/DCU/CA4/ca400_FinalYearProject/2024-ca400-olojob2-majdap2/src/backend/')
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi import APIRouter, Body, Request, status
 from pymongo import MongoClient
 from dotenv import dotenv_values
 from routes import router as api_router
@@ -58,35 +37,41 @@ import torch
 # --------------------------------- 
 import socketio
 
-DEBUG = True
+###############################################
+# Configure logger
 
-ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME = "remove_server_lock"
+logging.basicConfig(filename="backend.log",
+                    filemode='w',
+                    format='%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s',
+                    datefmt='%H:%M:%S',
+                    level=logging.DEBUG)
 
-TARGET_SAMPLING_RATE = 16000
-MAX_BYTES_BUFFER = 480_000
+# logger = logging.getLogger("socketio_server_pubsub")
+# gunicorn_logger.propagate = True
 
-print("")
-print("")
-print("=" * 20 + " ⭐️ Starting Server... ⭐️ " + "=" * 20)
+gunicorn_error_logger = logging.getLogger("gunicorn.error")
+gunicorn_logger = logging.getLogger("gunicorn")
+uvicorn_access_logger = logging.getLogger("uvicorn.access")
+
+gunicorn_error_logger.propagate = True
+gunicorn_logger.propagate = True
+uvicorn_access_logger.propagate = True
+
+uvicorn_access_logger.handlers = gunicorn_error_logger.handlers
+fastapi_logger.handlers = gunicorn_error_logger.handlers
 
-###############################################
-# Configure socketio server
 ###############################################
 
-# TODO PM - change this to the actual path
-# seamless remnant code
-CLIENT_BUILD_PATH = "../streaming-react-app/dist/"
-static_files = {
-    "/": CLIENT_BUILD_PATH,
-    "/assets/seamless-db6a2555.svg": {
-        "filename": CLIENT_BUILD_PATH + "assets/seamless-db6a2555.svg",
-        "content_type": "image/svg+xml",
-    },
-}
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-processor = AutoProcessor.from_pretrained("facebook/seamless-m4t-v2-large")
-# PM - hardcoding temporarily as my GPU doesnt have enough vram
-model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large").to("cpu")
+# sio is the main socket.io entrypoint
+sio = socketio.AsyncServer(
+    async_mode="asgi",
+    cors_allowed_origins="*",
+    logger=gunicorn_logger,
+    engineio_logger=gunicorn_logger,
+)
+# sio.logger.setLevel(logging.DEBUG)
+socketio_app = socketio.ASGIApp(sio)
+# app.mount("/", socketio_app)
 
 config = dotenv_values(".env")
 
@@ -114,7 +99,7 @@ async def lifespan(app: FastAPI):
     print("Closing MongoDB Connection...")
     app.mongodb_client.close()
 
-app = FastAPI(lifespan=lifespan, logger=logger)
+app = FastAPI(lifespan=lifespan, logger=gunicorn_logger)
 
 # New CORS funcitonality
 app.add_middleware(
@@ -127,19 +112,36 @@ app.add_middleware(
 
 app.include_router(api_router) # include routers for user, calls and transcripts operations
 
+DEBUG = True
 
-# sio is the main socket.io entrypoint
-sio = socketio.AsyncServer(
-    async_mode="asgi",
-    cors_allowed_origins="*",
-    logger=logger,
-    engineio_logger=logger,
-)
-# sio.logger.setLevel(logging.DEBUG)
-socketio_app = socketio.ASGIApp(sio)
-# app.mount("/", socketio_app)
+ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME = "remove_server_lock"
+
+TARGET_SAMPLING_RATE = 16000
+MAX_BYTES_BUFFER = 480_000
+
+print("")
+print("")
+print("=" * 20 + " ⭐️ Starting Server... ⭐️ " + "=" * 20)
+
+###############################################
+# Configure socketio server
+###############################################
+
+# TODO PM - change this to the actual path
+# seamless remnant code
+CLIENT_BUILD_PATH = "../streaming-react-app/dist/"
+static_files = {
+    "/": CLIENT_BUILD_PATH,
+    "/assets/seamless-db6a2555.svg": {
+        "filename": CLIENT_BUILD_PATH + "assets/seamless-db6a2555.svg",
+        "content_type": "image/svg+xml",
+    },
+}
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+processor = AutoProcessor.from_pretrained("facebook/seamless-m4t-v2-large")
+# PM - hardcoding temporarily as my GPU doesnt have enough vram
+model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large").to("cpu")
 
-from fastapi import APIRouter, Body, Request, status
 
 bytes_data = bytearray()
 model_name = "seamlessM4T_v2_large"
@@ -157,18 +159,24 @@ def get_collection_calls():
     return app.database["call_test"]
 
 
-@app.get("/test/", response_description="List all existing call records", response_model=List[UserCall])
+@app.get("/test/", response_description="Welcome User")
 def test():
 
-    result = list_calls(get_collection_calls(), 100)
+    return {"message": "Welcome to InterpreTalk!"}
 
-    # return {"message": "Welcome to InterpreTalk!"}
 
-    print(result)
-    return result
+@app.post("/test_post/", response_description="List more test call records")
+def test_post():
+    request_data = {
+        "call_id": "TESTID000001"
+    }
 
+    result = create_calls(get_collection_calls(), request_data)
 
-@app.put("/test_put/", response_description="List all existing call records", response_model=UserCall)
+    # return {"message": "Welcome to InterpreTalk!"}
+    return result
+
+@app.put("/test_put/", response_description="List test call records")
 def test_put():
 
     # result = list_calls(get_collection_calls(), 100)
@@ -179,18 +187,6 @@ def test_put():
     return result
 
 
-@app.post("/test_post/", response_description="List all existing call records", response_model=UserCall)
-def test_post():
-    request_data = {
-        "call_id": "TESTID000001"
-    }
-
-    result = create_calls(get_collection_calls(), request_data)
-
-    # return {"message": "Welcome to InterpreTalk!"}
-    return result
-
-
 async def send_translated_text(client_id, original_text, translated_text, room_id):
     print('SEND_TRANSLATED_TEXT IS WOKRING IN FASTAPI BACKEND...')
     print(rooms)
@@ -202,48 +198,48 @@ async def send_translated_text(client_id, original_text, translated_text, room_i
         "translated_text": str(translated_text),
         "timestamp": str(datetime.now())
     }
-    logger.warning("SENDING TRANSLATED TEXT TO CLIENT")
+    gunicorn_logger.info("SENDING TRANSLATED TEXT TO CLIENT")
     await sio.emit("translated_text", data, room=room_id)
-    logger.warning("SUCCESSFULLY SEND AUDIO TO FRONTEND")
+    gunicorn_logger.info("SUCCESSFULLY SEND AUDIO TO FRONTEND")
 
 @sio.on("connect")
 async def connect(sid, environ):
     print(f"📥 [event: connected] sid={sid}")
     query_params = dict(parse.parse_qsl(environ["QUERY_STRING"]))
     client_id = query_params.get("client_id")
-    logger.info(f"📥 [event: connected] sid={sid}, client_id={client_id}")
+    gunicorn_logger.info(f"📥 [event: connected] sid={sid}, client_id={client_id}")
     # sid = socketid, client_id = client specific ID ,always the same for same user
     clients[sid] = Client(sid, client_id)
-    logger.warning(f"Client connected: {sid}")
-    logger.warning(clients)
+    gunicorn_logger.warning(f"Client connected: {sid}")
+    gunicorn_logger.warning(clients)
 
 @sio.on("disconnect")
 async def disconnect(sid): # BO - also pass call id as parameter for updating MongoDB
-    logger.debug(f"📤 [event: disconnected] sid={sid}")
+    gunicorn_logger.debug(f"📤 [event: disconnected] sid={sid}")
     clients.pop(sid, None)
     # BO -> Update Call record with call duration, key terms
 
 @sio.on("target_language")
 async def target_language(sid, target_lang):
-    logger.info(f"📥 [event: target_language] sid={sid}, target_lang={target_lang}")
+    gunicorn_logger.info(f"📥 [event: target_language] sid={sid}, target_lang={target_lang}")
     clients[sid].target_language = target_lang
 
 @sio.on("call_user")
 async def call_user(sid, call_id):
     clients[sid].call_id = call_id
-    logger.warning(f"CALL {sid}: entering room {call_id}")
+    gunicorn_logger.info(f"CALL {sid}: entering room {call_id}")
     rooms[call_id] = rooms.get(call_id, [])
     if sid not in rooms[call_id] and len(rooms[call_id]) < 2:
         rooms[call_id].append(sid)
         sio.enter_room(sid, call_id)
     else:
-        logger.warning(f"CALL {sid}: room {call_id} is full")
+        gunicorn_logger.info(f"CALL {sid}: room {call_id} is full")
         # await sio.emit("room_full", room=call_id, to=sid)
 
     # # BO - Get call id from dictionary created during socketio connection
     # client_id = clients[sid].client_id
     
-    # logger.warning(f"NOW TRYING TO CREATE DB RECORD FOR Caller with ID: {client_id} for call: {call_id}")
+    # gunicorn_logger.warning(f"NOW TRYING TO CREATE DB RECORD FOR Caller with ID: {client_id} for call: {call_id}")
     # # # BO -> Create Call Record with Caller and call_id field (None for callee, duration, terms..)
     # request_data = {
     #     "call_id": str(call_id),
@@ -263,13 +259,13 @@ async def audio_config(sid, sample_rate):
 async def answer_call(sid, call_id):
 
     clients[sid].call_id = call_id
-    logger.warning(f"ANSWER {sid}: entering room {call_id}")
+    gunicorn_logger.info(f"ANSWER {sid}: entering room {call_id}")
     rooms[call_id] = rooms.get(call_id, [])
     if sid not in rooms[call_id] and len(rooms[call_id]) < 2:
         rooms[call_id].append(sid)
         sio.enter_room(sid, call_id)
     else:
-        logger.warning(f"ANSWER {sid}: room {call_id} is full")
+        gunicorn_logger.info(f"ANSWER {sid}: room {call_id} is full")
         # await sio.emit("room_full", room=call_id, to=sid)
 
 
@@ -277,7 +273,7 @@ async def answer_call(sid, call_id):
     # client_id = clients[sid].client_id
     
     # # BO -> Update Call Record with Callee field based on call_id
-    # logger.warning(f"NOW UPDATING MongoDB RECORD FOR Caller with ID: {client_id} for call: {call_id}")
+    # gunicorn_logger.warning(f"NOW UPDATING MongoDB RECORD FOR Caller with ID: {client_id} for call: {call_id}")
     # # # BO -> Create Call Record with callee_id field (None for callee, duration, terms..)
     # request_data = {
     #     "callee_id": client_id
@@ -293,13 +289,13 @@ async def incoming_audio(sid, data, call_id):
         clients[sid].add_bytes(data)
 
         if clients[sid].get_length() >= MAX_BYTES_BUFFER:
-            logger.warning('Buffer full, now outputting...')
+            gunicorn_logger.info('Buffer full, now outputting...')
             output_path = clients[sid].output_path
             vad_result, resampled_audio = clients[sid].resample_and_write_to_file()
             # source lang is speakers tgt language 😃
             src_lang = clients[sid].target_language
             if vad_result:
-                logger.warning('Speech detected, now processing audio.....')
+                gunicorn_logger.info('Speech detected, now processing audio.....')
                 tgt_sid = next(id for id in rooms[call_id] if id != sid)
                 tgt_lang = clients[tgt_sid].target_language
                 # following example from https://github.com/facebookresearch/seamless_communication/blob/main/docs/m4t/README.md#transformers-usage
@@ -326,7 +322,7 @@ async def incoming_audio(sid, data, call_id):
                 # send_captions(clients[sid].client_id, asr_text, translated_text, call_id)
 
     except Exception as e:
-        logger.error(f"Error in incoming_audio: {e.with_traceback()}")
+        gunicorn_logger.error(f"Error in incoming_audio: {e.with_traceback()}")
     
 def send_captions(client_id, original_text, translated_text, call_id):
     # BO -> Update Call Record with Callee field based on call_id    
@@ -345,6 +341,10 @@ def send_captions(client_id, original_text, translated_text, call_id):
 app.mount("/", socketio_app)
 
 if __name__ == '__main__':
+    uvicorn.run("main:app", host='127.0.0.1', port=8080, log_level="info")
+
+# Running in Docker Container
+if __name__ != "__main__":
     fastapi_logger.setLevel(gunicorn_logger.level)
 else:
     fastapi_logger.setLevel(logging.DEBUG)