Update backend/main.py

backend/main.py

@@ -1,362 +1,366 @@
-from operator import itemgetter
-import os
-from datetime import datetime
-import uvicorn
-from typing import Any, Optional, Tuple, Dict, TypedDict
-from urllib import parse
-from uuid import uuid4
-import logging
-from fastapi.logger import logger as fastapi_logger
-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
-from contextlib import asynccontextmanager
-import requests
-
-from typing import List
-from datetime import date
-from mongodb.operations.calls import *
-from mongodb.models.calls import UserCall, UpdateCall
-# from mongodb.endpoints.calls import *
-
-# from transformers import AutoProcessor, SeamlessM4Tv2Model
-
-# from seamless_communication.inference import Translator
-from Client import Client
-#----------------------------------
-# base seamless imports
-# --------------------------------- 
-import numpy as np
-import torch
-# --------------------------------- 
-import socketio
-
-###############################################
-# Configure logger
-
-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
-
-###############################################
-
-# 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")
-
-# Read connection string from environment vars
-# uri = os.environ['MONGODB_URI']
-
-# Read connection string from .env file
-uri = config['MONGODB_URI']
-
-# Set transformers cache
-# os.environ['HF_HOME'] = './.cache/'
-# os.environ['SENTENCE_TRANSFORMERS_HOME'] = './.cache'
-
-# MongoDB Connection Lifespan Events
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # startup logic
-    app.mongodb_client = MongoClient(uri)
-    app.database = app.mongodb_client['IT-Cluster1'] #connect to interpretalk primary db
-    try:
-        app.mongodb_client.admin.command('ping')
-        print("MongoDB Connection Established...")
-    except Exception as e:
-        print(e)
+# from operator import itemgetter
+# import os
+# from datetime import datetime
+# import uvicorn
+# from typing import Any, Optional, Tuple, Dict, TypedDict
+# from urllib import parse
+# from uuid import uuid4
+# import logging
+# from fastapi.logger import logger as fastapi_logger
+# 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
+# from contextlib import asynccontextmanager
+# import requests
+
+# from typing import List
+# from datetime import date
+# from mongodb.operations.calls import *
+# from mongodb.models.calls import UserCall, UpdateCall
+# # from mongodb.endpoints.calls import *
+
+# # from transformers import AutoProcessor, SeamlessM4Tv2Model
+
+# # from seamless_communication.inference import Translator
+# from Client import Client
+# #----------------------------------
+# # base seamless imports
+# # --------------------------------- 
+# import numpy as np
+# import torch
+# # --------------------------------- 
+# import socketio
+
+# ###############################################
+# # Configure logger
+
+# 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
+
+# ###############################################
+
+# # 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")
+
+# # Read connection string from environment vars
+# # uri = os.environ['MONGODB_URI']
+
+# # Read connection string from .env file
+# uri = config['MONGODB_URI']
+
+# # Set transformers cache
+# # os.environ['HF_HOME'] = './.cache/'
+# # os.environ['SENTENCE_TRANSFORMERS_HOME'] = './.cache'
+
+# # MongoDB Connection Lifespan Events
+# @asynccontextmanager
+# async def lifespan(app: FastAPI):
+#     # startup logic
+#     app.mongodb_client = MongoClient(uri)
+#     app.database = app.mongodb_client['IT-Cluster1'] #connect to interpretalk primary db
+#     try:
+#         app.mongodb_client.admin.command('ping')
+#         print("MongoDB Connection Established...")
+#     except Exception as e:
+#         print(e)
     
-    yield
+#     yield
 
-    # shutdown logic
-    print("Closing MongoDB Connection...")
-    app.mongodb_client.close()
+#     # shutdown logic
+#     print("Closing MongoDB Connection...")
+#     app.mongodb_client.close()
 
-app = FastAPI(lifespan=lifespan, logger=gunicorn_logger)
+# app = FastAPI(lifespan=lifespan, logger=gunicorn_logger)
 
-# New CORS funcitonality
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], # configured node app port
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# # New CORS funcitonality
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"], # configured node app port
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
 
-app.include_router(api_router) # include routers for user, calls and transcripts operations
+# app.include_router(api_router) # include routers for user, calls and transcripts operations
 
-DEBUG = True
+# DEBUG = True
 
-ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME = "remove_server_lock"
+# ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME = "remove_server_lock"
 
-TARGET_SAMPLING_RATE = 16000
-MAX_BYTES_BUFFER = 480_000
+# TARGET_SAMPLING_RATE = 16000
+# MAX_BYTES_BUFFER = 480_000
 
-print("")
-print("")
-print("=" * 20 + " ⭐️ Starting Server... ⭐️ " + "=" * 20)
+# print("")
+# print("")
+# print("=" * 20 + " ⭐️ Starting Server... ⭐️ " + "=" * 20)
 
-###############################################
-# Configure socketio server
-###############################################
+# ###############################################
+# # 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", force_download=True)
-#cache_dir="/.cache"
-
-# PM - hardcoding temporarily as my GPU doesnt have enough vram
-# model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large").to("cpu")
-# model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large", force_download=True).to(device)
-
-
-bytes_data = bytearray()
-model_name = "seamlessM4T_v2_large"
-# vocoder_name = "vocoder_v2" if model_name == "seamlessM4T_v2_large" else "vocoder_36langs"
-
-clients = {}
-rooms = {}
-
-import torch
-from transformers import pipeline
-translator = pipeline("automatic-speech-recognition",
-                      "facebook/seamless-m4t-v2-large",
-                      torch_dtype=torch.float32,
-                      device="cpu")
-
-converter = pipeline("translation",
-                      "facebook/seamless-m4t-v2-large",
-                      torch_dtype=torch.float32,
-                      device="cpu")
-
-
-def get_collection_users():
-    return app.database["user_records"]
-
-def get_collection_calls():
-    # return app.database["call_records"]
-    return app.database["call_test"]
-
-
-@app.get("/test/", response_description="Welcome User")
-def test():
-
-    return {"message": "Welcome to InterpreTalk!"}
-
-
-@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)
-
-    # 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)
-    # result = send_captions("TEST", "TEST", "TEST", "oUjUxTYTQFVVjEarIcZ0")
-    result = send_captions("TEST", "TEST", "TEST", "TESTID000001")
-
-    print(result)
-    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)
-    print(clients)
-
-    data = {
-        "author": str(client_id),
-        "original_text": str(original_text),
-        "translated_text": str(translated_text),
-        "timestamp": str(datetime.now())
-    }
-    gunicorn_logger.info("SENDING TRANSLATED TEXT TO CLIENT")
-    await sio.emit("translated_text", data, room=room_id)
-    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")
-    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)
-    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
-    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):
-    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
-    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:
-        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
+# # 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", force_download=True)
+# #cache_dir="/.cache"
+
+# # PM - hardcoding temporarily as my GPU doesnt have enough vram
+# # model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large").to("cpu")
+# # model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large", force_download=True).to(device)
+
+
+# bytes_data = bytearray()
+# model_name = "seamlessM4T_v2_large"
+# # vocoder_name = "vocoder_v2" if model_name == "seamlessM4T_v2_large" else "vocoder_36langs"
+
+# clients = {}
+# rooms = {}
+
+# import torch
+# from transformers import pipeline
+# translator = pipeline("automatic-speech-recognition",
+#                       "facebook/seamless-m4t-v2-large",
+#                       torch_dtype=torch.float32,
+#                       device="cpu")
+
+# converter = pipeline("translation",
+#                       "facebook/seamless-m4t-v2-large",
+#                       torch_dtype=torch.float32,
+#                       device="cpu")
+
+
+# def get_collection_users():
+#     return app.database["user_records"]
+
+# def get_collection_calls():
+#     # return app.database["call_records"]
+#     return app.database["call_test"]
+
+
+# @app.get("/test/", response_description="Welcome User")
+# def test():
+
+#     return {"message": "Welcome to InterpreTalk!"}
+
+
+# @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)
+
+#     # 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)
+#     # result = send_captions("TEST", "TEST", "TEST", "oUjUxTYTQFVVjEarIcZ0")
+#     result = send_captions("TEST", "TEST", "TEST", "TESTID000001")
+
+#     print(result)
+#     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)
+#     print(clients)
+
+#     data = {
+#         "author": str(client_id),
+#         "original_text": str(original_text),
+#         "translated_text": str(translated_text),
+#         "timestamp": str(datetime.now())
+#     }
+#     gunicorn_logger.info("SENDING TRANSLATED TEXT TO CLIENT")
+#     await sio.emit("translated_text", data, room=room_id)
+#     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")
+#     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)
+#     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
+#     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):
+#     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
+#     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:
+#         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
     
-    # 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),
-    #     "caller_id": str(client_id),
-    #     "creation_date": str(datetime.now())
-    # }
-
-    # response =  create_calls(get_collection_calls(), request_data)
-    # print(response) # BO - print created db call record
-
-@sio.on("audio_config")
-async def audio_config(sid, sample_rate):
-    clients[sid].original_sr = sample_rate
-
-
-@sio.on("answer_call")
-async def answer_call(sid, call_id):
-
-    clients[sid].call_id = 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:
-        gunicorn_logger.info(f"ANSWER {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
+#     # 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),
+#     #     "caller_id": str(client_id),
+#     #     "creation_date": str(datetime.now())
+#     # }
+
+#     # response =  create_calls(get_collection_calls(), request_data)
+#     # print(response) # BO - print created db call record
+
+# @sio.on("audio_config")
+# async def audio_config(sid, sample_rate):
+#     clients[sid].original_sr = sample_rate
+
+
+# @sio.on("answer_call")
+# async def answer_call(sid, call_id):
+
+#     clients[sid].call_id = 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:
+#         gunicorn_logger.info(f"ANSWER {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
     
-    # # BO -> Update Call Record with Callee field based on 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
-    # }
-
-    # response =  update_calls(get_collection_calls(), call_id, request_data)
-    # print(response) # BO - print created db call record
+#     # # BO -> Update Call Record with Callee field based on 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
+#     # }
+
+#     # response =  update_calls(get_collection_calls(), call_id, request_data)
+#     # print(response) # BO - print created db call record
     
 
-@sio.on("incoming_audio")
-async def incoming_audio(sid, data, call_id):
-    try:
-        clients[sid].add_bytes(data)
-
-        if clients[sid].get_length() >= MAX_BYTES_BUFFER:
-            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:
-                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
-                # output_tokens = processor(audios=resampled_audio, src_lang=src_lang, return_tensors="pt")
-                # model_output = model.generate(**output_tokens, tgt_lang=src_lang, generate_speech=False)[0].tolist()[0]
-                # asr_text = processor.decode(model_output, skip_special_tokens=True)
-                asr_text = translator(resampled_audio, generate_kwargs={"tgt_lang": src_lang})['text']
-                print(f"ASR TEXT = {asr_text}")
-                # ASR TEXT => ORIGINAL TEXT
-
-                # t2t_tokens = processor(text=asr_text, src_lang=src_lang, tgt_lang=tgt_lang, return_tensors="pt")
-                # print(f"FIRST TYPE = {type(output_tokens)}, SECOND TYPE = {type(t2t_tokens)}")
-                # translated_data = model.generate(**t2t_tokens, tgt_lang=tgt_lang, generate_speech=False)[0].tolist()[0]
-                # translated_text = processor.decode(translated_data, skip_special_tokens=True)
-                translated_text = converter(asr_text, src_lang=src_lang, tgt_lang=tgt_lang)
-                print(f"TRANSLATED TEXT = {translated_text}")
-
-                # BO -> send translated_text to mongodb as caption record update based on call_id
-                # send_captions(clients[sid].client_id, asr_text, translated_text, call_id)
+# @sio.on("incoming_audio")
+# async def incoming_audio(sid, data, call_id):
+#     try:
+#         clients[sid].add_bytes(data)
+
+#         if clients[sid].get_length() >= MAX_BYTES_BUFFER:
+#             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:
+#                 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
+#                 # output_tokens = processor(audios=resampled_audio, src_lang=src_lang, return_tensors="pt")
+#                 # model_output = model.generate(**output_tokens, tgt_lang=src_lang, generate_speech=False)[0].tolist()[0]
+#                 # asr_text = processor.decode(model_output, skip_special_tokens=True)
+#                 asr_text = translator(resampled_audio, generate_kwargs={"tgt_lang": src_lang})['text']
+#                 print(f"ASR TEXT = {asr_text}")
+#                 # ASR TEXT => ORIGINAL TEXT
+
+#                 # t2t_tokens = processor(text=asr_text, src_lang=src_lang, tgt_lang=tgt_lang, return_tensors="pt")
+#                 # print(f"FIRST TYPE = {type(output_tokens)}, SECOND TYPE = {type(t2t_tokens)}")
+#                 # translated_data = model.generate(**t2t_tokens, tgt_lang=tgt_lang, generate_speech=False)[0].tolist()[0]
+#                 # translated_text = processor.decode(translated_data, skip_special_tokens=True)
+#                 translated_text = converter(asr_text, src_lang=src_lang, tgt_lang=tgt_lang)
+#                 print(f"TRANSLATED TEXT = {translated_text}")
+
+#                 # BO -> send translated_text to mongodb as caption record update based on call_id
+#                 # send_captions(clients[sid].client_id, asr_text, translated_text, call_id)
                 
-                # TRANSLATED TEXT
-                # PM - text_output is a list with 1 string
-                await send_translated_text(clients[sid].client_id, asr_text, translated_text, call_id)
+#                 # TRANSLATED TEXT
+#                 # PM - text_output is a list with 1 string
+#                 await send_translated_text(clients[sid].client_id, asr_text, translated_text, call_id)
 
-                # # BO -> send translated_text to mongodb as caption record update based on call_id
-                # send_captions(clients[sid].client_id, asr_text, translated_text, call_id)
+#                 # # BO -> send translated_text to mongodb as caption record update based on call_id
+#                 # send_captions(clients[sid].client_id, asr_text, translated_text, call_id)
 
-    except Exception as e:
-        gunicorn_logger.error(f"Error in incoming_audio: {e.with_traceback()}")
+#     except Exception as e:
+#         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    
-    print(f"Now updating Caption field in call record for Caller with ID: {client_id} for call: {call_id}")
-
-    data = {
-        "author": str(client_id),
-        "original_text": str(original_text),
-        "translated_text": str(translated_text),
-        "timestamp": str(datetime.now())
-    }
-
-    response =  update_captions(get_collection_calls(), call_id, data)
-    return response
-
-app.mount("/", socketio_app)
-
-if __name__ == '__main__':
-    uvicorn.run("main:app", host='0.0.0.0', port=7860, log_level="debug")
-
-# Running in Docker Container
-if __name__ != "__main__":
-    fastapi_logger.setLevel(gunicorn_logger.level)
-else:
-    fastapi_logger.setLevel(logging.DEBUG)
+# def send_captions(client_id, original_text, translated_text, call_id):
+#     # BO -> Update Call Record with Callee field based on call_id    
+#     print(f"Now updating Caption field in call record for Caller with ID: {client_id} for call: {call_id}")
+
+#     data = {
+#         "author": str(client_id),
+#         "original_text": str(original_text),
+#         "translated_text": str(translated_text),
+#         "timestamp": str(datetime.now())
+#     }
+
+#     response =  update_captions(get_collection_calls(), call_id, data)
+#     return response
+
+# app.mount("/", socketio_app)
+
+# if __name__ == '__main__':
+#     uvicorn.run("main:app", host='0.0.0.0', port=7860, log_level="debug")
+
+# # Running in Docker Container
+# if __name__ != "__main__":
+#     fastapi_logger.setLevel(gunicorn_logger.level)
+# else:
+#     fastapi_logger.setLevel(logging.DEBUG)
+
+from huggingface_hub import scan_cache_dir
+
+hf_cache_info = scan_cache_dir()