Updated v3

app/api/endpoints/transcribe.py

@@ -1,11 +1,17 @@
 from typing import Annotated, List, Union
 
 from fastapi import APIRouter, File, UploadFile, Request, Header, HTTPException
+from fastapi.background import BackgroundTasks
 from pydantic import BaseModel
 
-from app.utils.utils import save_audio_file, transcribeFile
+from app.core.database import SessionLocal
+
+from app.utils.utils import save_audio_file, transcribe_file, get_audio_duration
+from app.core.models import AuthTokenController, TranscribeController
+
 
 router = APIRouter()
+database = SessionLocal()
 
 
 class Transcription(BaseModel):
@@ -15,16 +21,24 @@ class Transcription(BaseModel):
 
 @router.post("/", response_model=Transcription)
 async def post_audio(
+    background_tasks: BackgroundTasks,
     request: Request,
     file: UploadFile = File(...),
     Authentication: Annotated[Union[str, None], Header()] = None,
 ):
-    print(f"Authorization header: {Authentication}")
-
     try:
-        """Receive audio file and save it to disk. and then transcribe the audio file"""
+        userId = AuthTokenController(database).get_userid_from_token(Authentication)
         file_path = save_audio_file(file)
-        data = transcribeFile(file_path)
+        [data, output_audio_path] = transcribe_file(file_path)
+        background_tasks.add_task(
+            create_transcribe_record, database, userId, data, output_audio_path
+        )
+
         return Transcription(filename=file.filename, text=data)
     except Exception as e:
         raise HTTPException(status_code=400, detail=e.__str__())
+
+
+def create_transcribe_record(database, userId, data, file_path):
+    duration = get_audio_duration(file_path)
+    TranscribeController(database).create(user_id=userId, text=data, duration=duration)

app/core/models/AuthToken.py

@@ -1,4 +1,3 @@
-from datetime import datetime, timedelta
 import uuid
 import random
 import string
@@ -7,6 +6,8 @@ from app.core.config import settings
 
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy import Column, String, Boolean, ForeignKey, DateTime
+from sqlalchemy.orm import relationship
+
 from sqlalchemy.sql import func
 
 from app.core.database import Base
@@ -19,10 +20,35 @@ class AuthToken(Base):
     token = Column(String, unique=True, index=True)
     user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"))
     created_at = Column(DateTime(timezone=True), server_default=func.now())
+    user = relationship("UserInDB", back_populates="auth_tokens")
+
+    def __init__(self, user_id: UUID, token: str):
+        self.user_id = user_id
+        self.token = token
+
 
-    def __init__(self, user_id: UUID):
+class AuthTokenController:
+    AuthToken = AuthToken
+
+    def __init__(self, database):
+        self.db = database
+
+    def get_userid_from_token(self, token) -> str:
+        user = self.db.query(AuthToken).filter(AuthToken.token == token).first()
+        if not user:
+            raise Exception("Invalid Token!")
+        return user.user_id
+
+    def create(self, user_id: UUID):
         self.user_id = user_id
         self.token = self.create_token()
+        self.auth_token = AuthToken(self.user_id, self.token)
+        self.db.add(self.auth_token)
+        self.db.commit()
+        self.db.refresh(self.auth_token)
+
+    def get_token(self):
+        return self.auth_token.token
 
     def create_token(self):
         token = self.generate_bearer_token()

app/core/models/Transcribe.py

@@ -4,7 +4,7 @@ import uuid
 from app.core.config import settings
 
 from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy import Column, String, Boolean, ForeignKey, DateTime
+from sqlalchemy import Column, String, Boolean, ForeignKey, DateTime, Integer
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.sql import func
 
@@ -16,6 +16,30 @@ class TranscibeInDB(Base):
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     text = Column(String)
+    audio_duration = Column(Integer)
     user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"))
     user = relationship("UserInDB", back_populates="transcribes")
     created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    def __init__(self, user_id, text, audio_duration):
+        self.text = text
+        self.audio_duration = audio_duration
+        self.user_id = user_id
+
+
+class TranscribeController:
+    TranscibeInDB = TranscibeInDB
+
+    def __init__(self, database):
+        self.db = database
+
+    def create(self, user_id: UUID, text: str, duration: int):
+        self.user_id = user_id
+        self.text = text
+        self.audio_duration = duration
+        self.transcribe_data = TranscibeInDB(
+            user_id=self.user_id, text=self.text, audio_duration=self.audio_duration
+        )
+        self.db.add(self.transcribe_data)
+        self.db.commit()
+        self.db.refresh(self.transcribe_data)

app/core/models/User.py

@@ -1,6 +1,5 @@
 import uuid
 
-
 from app.core.config import settings
 
 from sqlalchemy.dialects.postgresql import UUID
@@ -12,6 +11,8 @@ from app.core.database import Base
 
 from app.core.security import get_password_hash, verify_password
 
+from app.core.models import AuthTokenController
+
 
 class UserInDB(Base):
     __tablename__ = "users"
@@ -22,6 +23,7 @@ class UserInDB(Base):
     hashed_password = Column(String)
     is_active = Column(Boolean, default=True)
     transcribes = relationship("TranscibeInDB", back_populates="user")
+    auth_tokens = relationship("AuthToken", back_populates="user")
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     def __init__(self, username: str, email: str, hashed_password: str):
@@ -44,7 +46,7 @@ class UserController:
     def __init__(self, database):
         self.db = database
 
-    def create(self, username: str, email: str, password: str):
+    def create(self, username: str, email: str, password: str, init_token: bool = True):
         isUserExists: Boolean = self.CheckUserIsExistsByEmailAndUsername(
             email, username
         )
@@ -65,6 +67,10 @@ class UserController:
         self.db.refresh(self.db_user)
         self.user = self.db_user.data()
 
+        if init_token == False:
+            return
+        AuthTokenController(self.db).create(self.db_user.id)
+
     def CheckUserIsExistsByEmailAndUsername(self, email: str, username: str):
         db_user = (
             self.db.query(UserInDB)

app/core/models/__init__.py

@@ -1,6 +1,6 @@
-from .AuthToken import AuthToken
+from .AuthToken import AuthToken, AuthTokenController
 from .User import UserInDB
-from .Transcribe import TranscibeInDB
+from .Transcribe import TranscibeInDB, TranscribeController
 
 from app.core.database import Base, engine
 

app/utils/utils.py

@@ -2,6 +2,7 @@ import json
 import subprocess
 import uuid
 import logging
+import wave
 
 
 def get_all_routes(app):
@@ -33,18 +34,20 @@ def print_routes(app):
     print("\n")
 
 
-def transcribeFile(path: str = None, model="ggml-model-whisper-tiny.en-q5_1.bin"):
-    """./binary/whisper -m models/ggml-tiny.en.bin -f Rev.mp3 -nt --output-text out1.txt"""
+def transcribe_file(path: str = None, model="ggml-model-whisper-tiny.en-q5_1.bin"):
+    """./binary/whisper -m models/ggml-tiny.en.bin -f Rev.mp3 out.wav -nt --output-text out1.txt"""
     try:
         if path is None:
             raise Exception("No path provided")
-        outputFilePath: str = f"transcribe/{uuid.uuid4()}.txt"
-        command: str = f"./binary/whisper -m models/{model} -f {path} -nt --output-text {outputFilePath}"
+        rand = uuid.uuid4()
+        outputFilePath: str = f"transcribe/{rand}.txt"
+        output_audio_path: str = f"audio/{rand}.wav"
+        command: str = f"./binary/whisper -m models/{model} -f {path} {output_audio_path} -nt --output-text {outputFilePath}"
         execute_command(command)
         f = open(outputFilePath, "r")
         data = f.read()
         f.close()
-        return data
+        return [data, output_audio_path]
     except Exception as e:
         logging.error(e)
         raise Exception(e.__str__())
@@ -66,3 +69,22 @@ def save_audio_file(file=None):
     with open(path, "wb") as f:
         f.write(file.file.read())
     return path
+
+
+def get_audio_duration(audio_file):
+    """Gets the duration of the audio file in seconds.
+
+    Args:
+      audio_file: The path to the audio file.
+
+    Returns:
+      The duration of the audio file in seconds.
+    """
+
+    with wave.open(audio_file, "rb") as f:
+        frames = f.getnframes()
+        sample_rate = f.getframerate()
+        duration = frames / sample_rate
+        rounded_duration = int(round(duration, 0))
+
+    return rounded_duration