Update main.py

main.py

@@ -5,8 +5,10 @@ import asyncio
 import sqlite3
 import bcrypt
 import tempfile
+import shutil
+import subprocess # to use "ffmpeg" in order to use "ffmpeg-python" library for video to audio conversion
 from fastapi import FastAPI, Request, Query, Form, UploadFile, File, HTTPException, Depends
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
@@ -47,7 +49,11 @@ the following products are spelled correctly
 # Authentication & Security
 SECRET_KEY = os.getenv("SECRET_KEY", None)  # Change in production
 ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
+ACCESS_TOKEN_EXPIRE_MINUTES = 60
+
+# Directory definitions
+UPLOAD_DIR = "uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
 
 # Database setup
 DB_TYPE = os.getenv("DB_TYPE", "sqlite").lower()  # Default to SQLite if not specified
@@ -90,6 +96,7 @@ class UserModel(Base):
     disabled = Column(Boolean, default=True)  # Default to disabled
     is_admin = Column(Boolean, default=False)  # Add admin field
 
+
 # Create tables
 Base.metadata.create_all(bind=engine)
 
@@ -115,7 +122,7 @@ class User(UserBase):
     is_admin: bool = False  # Add admin field
     
     class Config:
-        orm_mode = True
+        from_attributes = True
 
 class Token(BaseModel):
     access_token: str
@@ -152,7 +159,7 @@ class Transcription(TranscriptionBase):
     created_at: str
     
     class Config:
-        orm_mode = True
+        from_attributes = True
 
 # Add these utilities
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
@@ -346,7 +353,7 @@ def create_access_token(data: dict, expires_delta: timedelta | None = None):
     if expires_delta:
         expire = datetime.utcnow() + expires_delta
     else:
-        expire = datetime.utcnow() + timedelta(minutes=15)
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
     to_encode.update({"exp": expire})
     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
     return encoded_jwt
@@ -391,7 +398,7 @@ app.add_middleware(
 )
 
 # Also ensure your login form data is properly sent
-@app.post("/token")
+@app.post("/token") #, response_model=Token)
 async def login_for_access_token(
     form_data: OAuth2PasswordRequestForm = Depends(),
     db: Session = Depends(get_db)
@@ -409,7 +416,8 @@ async def login_for_access_token(
                 status_code=400,
                 detail="User is disabled"
             )
-        access_token = create_access_token(data={"sub": user.username})
+        access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+        access_token = create_access_token(data={"sub": user.username}, expires_delta=access_token_expires)
         return {"access_token": access_token, "token_type": "bearer"}
     except Exception as e:
         print(f"Login error: {str(e)}")  # Add logging for debugging
@@ -759,6 +767,159 @@ async def upload_audio(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.post("/api/upload-audio-chunk")
+async def upload_audio_chunk(
+    file: UploadFile = File(...),
+    upload_id: str = Form(...),
+    offset: int = Form(...),
+    total_size: int = Form(...),
+    current_user: User = Depends(get_current_user)
+):
+    # Create upload directory for this file in system temp directory
+    temp_dir = tempfile.gettempdir()
+    upload_path = os.path.join(temp_dir, f"transtudio_upload_{upload_id}")
+    os.makedirs(upload_path, exist_ok=True)
+    
+    # Path for this specific chunk
+    chunk_path = os.path.join(upload_path, f"chunk_{offset}")
+    
+    # Save the chunk
+    with open(chunk_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    # Update metadata file with progress info
+    metadata_path = os.path.join(upload_path, "metadata.txt")
+    with open(metadata_path, "w") as f:
+        f.write(f"{offset + file.size}/{total_size}")
+    
+    return {"success": True, "received_bytes": offset + file.size}
+
+@app.post("/api/finalize-audio-upload")
+async def finalize_audio_upload(
+    upload_info: dict,
+    current_user: User = Depends(get_current_user)
+):
+    upload_id = upload_info.get("upload_id")
+    if not upload_id:
+        raise HTTPException(status_code=400, detail="Upload ID is required")
+    
+    temp_dir = tempfile.gettempdir()
+    upload_path = os.path.join(temp_dir, f"transtudio_upload_{upload_id}")
+    if not os.path.exists(upload_path):
+        raise HTTPException(status_code=404, detail="Upload not found")
+    
+    # Read metadata to get original filename if available
+    metadata_path = os.path.join(upload_path, "metadata.txt")
+    filename = f"{uuid.uuid4()}.mp3"  # Default filename
+    
+    # Combine all chunks into final file
+    output_path = os.path.join(UPLOAD_DIR, filename)
+    
+    with open(output_path, "wb") as outfile:
+        # Get all chunks sorted by offset
+        chunks = [f for f in os.listdir(upload_path) if f.startswith("chunk_")]
+        chunks.sort(key=lambda x: int(x.split("_")[1]))
+        
+        for chunk_name in chunks:
+            chunk_path = os.path.join(upload_path, chunk_name)
+            with open(chunk_path, "rb") as infile:
+                shutil.copyfileobj(infile, outfile)
+    
+    # Clean up temporary files
+    shutil.rmtree(upload_path)
+    
+    return {"success": True, "filename": filename}
+
+@app.post("/api/cancel-audio-upload")
+async def cancel_audio_upload(
+    upload_info: dict,
+    current_user: User = Depends(get_current_user)
+):
+    upload_id = upload_info.get("upload_id")
+    if not upload_id:
+        raise HTTPException(status_code=400, detail="Upload ID is required")
+    
+    temp_dir = tempfile.gettempdir()
+    upload_path = os.path.join(temp_dir, f"transtudio_upload_{upload_id}")
+    if os.path.exists(upload_path):
+        shutil.rmtree(upload_path)
+    
+    return {"success": True}
+
+@app.get("/api/audio-files")
+async def get_audio_files(
+    current_user: User = Depends(get_current_user)
+):
+    try:
+        # Scan uploads directory for audio files
+        upload_dir = os.path.join(os.getcwd(), UPLOAD_DIR)
+        file_list = []
+        
+        for filename in os.listdir(upload_dir):
+            file_path = os.path.join(upload_dir, filename)
+            if os.path.isfile(file_path) and not filename.startswith('.'):
+                # Get file stats
+                file_stats = os.stat(file_path)
+                file_size = os.path.getsize(file_path)
+                
+                file_list.append({
+                    "id": filename,  # Use filename as ID
+                    "filename": filename,
+                    "original_filename": filename,
+                    "size": file_size,
+                    "uploaded_at": datetime.fromtimestamp(file_stats.st_mtime).isoformat()
+                })
+        
+        # Sort by upload date (newest first)
+        file_list.sort(key=lambda x: x["uploaded_at"], reverse=True)
+        
+        return file_list
+    except Exception as e:
+        print(f"Error getting audio files: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/api/audio-files/{filename}")
+async def delete_audio_file(
+    filename: str,
+    current_user: User = Depends(get_current_user)
+):
+    try:
+        # Check if file exists in uploads directory
+        file_path = os.path.join(os.getcwd(), UPLOAD_DIR, filename)
+        if not os.path.exists(file_path):
+            raise HTTPException(status_code=404, detail="Audio file not found")
+        
+        # Delete the physical file
+        os.remove(file_path)
+        
+        return {"status": "success", "message": "Audio file deleted successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error deleting audio file: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/extract-audio/")
+async def extract_audio(file: UploadFile = File(...)):
+    # Save uploaded video temporarily
+    video_path = f"temp/{file.filename}"
+    audio_path = f"temp/{os.path.splitext(file.filename)[0]}.mp3"
+    
+    with open(video_path, "wb") as buffer:
+        buffer.write(await file.read())
+    
+    # Extract audio using FFmpeg
+    subprocess.run([
+        "ffmpeg", "-i", video_path, 
+        "-q:a", "0", "-map", "a", audio_path
+    ])
+    
+    # Clean up video file
+    os.remove(video_path)
+    
+    # Return audio file
+    return FileResponse(audio_path)
+
 @app.get("/api/transcriptions")
 async def get_transcriptions(
     current_user: User = Depends(get_current_user),