Upload folder using huggingface_hub

api/flashcards.py

@@ -1,74 +1,46 @@
 import logging
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
 from sqlalchemy.orm import Session
 from typing import List, Dict
+import asyncio
+from datetime import datetime
 
 from api.auth import get_current_user
 from models import db_models
 from models.schemas import FlashcardGenerateRequest, FlashcardSetResponse, FlashcardResponse
-from core.database import get_db
+from core.database import get_db, SessionLocal
+from api.websocket_routes import manager
 from services.flashcard_service import flashcard_service
 from core import constants
 
 router = APIRouter(prefix="/api/flashcards", tags=["flashcards"])
 logger = logging.getLogger(__name__)
 
-@router.get("/config")
-async def get_flashcard_config():
-    """Returns available difficulties, quantities, and languages for flashcards."""
-    return {
-        "difficulties": constants.DIFFICULTIES,
-        "quantities": constants.FLASHCARD_QUANTITIES,
-        "languages": constants.LANGUAGES
-    }
-
-@router.post("/generate", response_model=FlashcardSetResponse)
-async def generate_flashcards(
-    request: FlashcardGenerateRequest,
-    current_user: db_models.User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    """
-    Generates a set of flashcards and saves them to the database.
-    """
+async def run_flashcard_generation(set_id: int, request: FlashcardGenerateRequest, user_id: int):
+    """Background task for flashcard generation"""
+    db = SessionLocal()
+    connection_id = f"user_{user_id}"
     try:
-        source_id = None
-        if request.file_key:
-            # Verify file ownership
-            source = db.query(db_models.Source).filter(
-                db_models.Source.s3_key == request.file_key,
-                db_models.Source.user_id == current_user.id
-            ).first()
-            if not source:
-                raise HTTPException(status_code=403, detail="Not authorized to access this file")
-            source_id = source.id
-
-        # 1. Generate Flashcards from AI
+        db_set = db.query(db_models.FlashcardSet).filter(db_models.FlashcardSet.id == set_id).first()
+        if not db_set: return
+
+        # Call AI service
         cards_data = await flashcard_service.generate_flashcards(
             file_key=request.file_key,
             text_input=request.text_input,
             difficulty=request.difficulty,
             quantity=request.quantity,
             topic=request.topic,
-            language=request.language
+            language=request.language,
+            progress_callback=lambda p, m: asyncio.create_task(
+                manager.send_progress(connection_id, p, "processing", m)
+            )
         )
 
         if not cards_data:
-            raise HTTPException(status_code=500, detail="AI returned an empty response")
+            raise Exception("AI returned empty flashcards data")
 
-        # 2. Save Flashcard Set to DB
-        title = request.topic if request.topic else f"Flashcards {len(cards_data)}"
-        db_set = db_models.FlashcardSet(
-            title=title,
-            difficulty=request.difficulty,
-            user_id=current_user.id,
-            source_id=source_id
-        )
-        db.add(db_set)
-        db.commit()
-        db.refresh(db_set)
-
-        # 3. Save individual flashcards
+        # Save individual cards
         for item in cards_data:
             db_card = db_models.Flashcard(
                 flashcard_set_id=db_set.id,
@@ -77,24 +49,74 @@ async def generate_flashcards(
             )
             db.add(db_card)
         
+        db_set.status = "completed"
         db.commit()
-        db.refresh(db_set)
 
-        return {
+        # Notify via WebSocket
+        await manager.send_result(connection_id, {
+            "type": "flashcards",
             "id": db_set.id,
-            "title": db_set.title,
-            "difficulty": db_set.difficulty,
-            "created_at": db_set.created_at,
-            "parent_file_id": db_set.source_id,
-            "parent_file_key": source.s3_key if source else None,
-            "flashcards": db_set.flashcards
-        }
-
-    except HTTPException:
-        raise
+            "status": "completed",
+            "title": db_set.title
+        })
+
     except Exception as e:
-        logger.error(f"Flashcard generation endpoint failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Background flashcard generation failed: {e}")
+        db_set = db.query(db_models.FlashcardSet).filter(db_models.FlashcardSet.id == set_id).first()
+        if db_set:
+            db_set.status = "failed"
+            db_set.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, f"Flashcard generation failed: {str(e)}")
+    finally:
+        db.close()
+
+@router.get("/config")
+async def get_flashcard_config():
+    """Returns available difficulties, quantities, and languages for flashcards."""
+    return {
+        "difficulties": constants.DIFFICULTIES,
+        "quantities": constants.FLASHCARD_QUANTITIES,
+        "languages": constants.LANGUAGES
+    }
+
+@router.post("/generate", response_model=FlashcardSetResponse)
+async def generate_flashcards(
+    request: FlashcardGenerateRequest,
+    background_tasks: BackgroundTasks,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Initiates flashcard generation in the background.
+    """
+    source_id = None
+    if request.file_key:
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        if not source:
+            raise HTTPException(status_code=403, detail="Not authorized to access this file")
+        source_id = source.id
+
+    # Create initial processing record
+    title = request.topic if request.topic else f"Flashcards {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+    db_set = db_models.FlashcardSet(
+        title=title,
+        difficulty=request.difficulty,
+        user_id=current_user.id,
+        source_id=source_id,
+        status="processing"
+    )
+    db.add(db_set)
+    db.commit()
+    db.refresh(db_set)
+
+    # Offload to background task
+    background_tasks.add_task(run_flashcard_generation, db_set.id, request, current_user.id)
+
+    return db_set
 
 @router.get("/sets", response_model=List[FlashcardSetResponse])
 async def list_flashcard_sets(
@@ -108,18 +130,7 @@ async def list_flashcard_sets(
         sets = db.query(db_models.FlashcardSet).filter(
             db_models.FlashcardSet.user_id == current_user.id
         ).order_by(db_models.FlashcardSet.created_at.desc()).all()
-        return [
-            {
-                "id": s.id,
-                "title": s.title,
-                "difficulty": s.difficulty,
-                "created_at": s.created_at,
-                "parent_file_id": s.source_id,
-                "parent_file_key": s.source.s3_key if s.source else None,
-                "flashcards": s.flashcards
-            }
-            for s in sets
-        ]
+        return [FlashcardSetResponse.model_validate(s) for s in sets]
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -140,15 +151,7 @@ async def get_flashcard_set(
     if not db_set:
         raise HTTPException(status_code=404, detail="Flashcard set not found")
     
-    return {
-        "id": db_set.id,
-        "title": db_set.title,
-        "difficulty": db_set.difficulty,
-        "created_at": db_set.created_at,
-        "parent_file_id": db_set.source_id,
-        "parent_file_key": db_set.source.s3_key if db_set.source else None,
-        "flashcards": db_set.flashcards
-    }
+    return FlashcardSetResponse.model_validate(db_set)
 
 @router.post("/explain")
 async def explain_flashcard(

api/mindmaps.py

@@ -1,74 +1,98 @@
 import logging
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
 from sqlalchemy.orm import Session
 from typing import List
+from datetime import datetime
 
 from api.auth import get_current_user
 from models import db_models
 from models.schemas import MindMapGenerateRequest, MindMapResponse
-from core.database import get_db
+from core.database import get_db, SessionLocal
+from api.websocket_routes import manager
 from services.mindmap_service import mindmap_service
 
 router = APIRouter(prefix="/api/mindmaps", tags=["mindmaps"])
 logger = logging.getLogger(__name__)
 
-@router.post("/generate", response_model=MindMapResponse)
-async def generate_mindmap(
-    request: MindMapGenerateRequest,
-    current_user: db_models.User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    """
-    Generates a mind map in Mermaid format and saves it to the database.
-    """
+async def run_mindmap_generation(mindmap_id: int, request: MindMapGenerateRequest, user_id: int):
+    """Background task for mind map generation"""
+    db = SessionLocal()
+    connection_id = f"user_{user_id}"
     try:
-        source_id = None
-        if request.file_key:
-            # Verify file ownership
-            source = db.query(db_models.Source).filter(
-                db_models.Source.s3_key == request.file_key,
-                db_models.Source.user_id == current_user.id
-            ).first()
-            if not source:
-                raise HTTPException(status_code=403, detail="Not authorized to access this file")
-            source_id = source.id
+        db_mindmap = db.query(db_models.MindMap).filter(db_models.MindMap.id == mindmap_id).first()
+        if not db_mindmap: return
 
-        # 1. Generate Mind Map from AI
+        # Call AI service
         mermaid_code = await mindmap_service.generate_mindmap(
             file_key=request.file_key,
             text_input=request.text_input
         )
 
         if not mermaid_code:
-            raise HTTPException(status_code=500, detail="Failed to generate mind map")
+            raise Exception("AI failed to generate mind map code")
 
-        # 2. Save to DB
-        title = request.title if request.title else (request.file_key.split('/')[-1] if request.file_key else "Untitled Mind Map")
-        db_mindmap = db_models.MindMap(
-            title=title,
-            mermaid_code=mermaid_code,
-            user_id=current_user.id,
-            source_id=source_id
-        )
-        db.add(db_mindmap)
+        db_mindmap.mermaid_code = mermaid_code
+        db_mindmap.status = "completed"
         db.commit()
-        db.refresh(db_mindmap)
 
-        return MindMapResponse(
-            id=db_mindmap.id,
-            title=db_mindmap.title,
-            mermaid_code=db_mindmap.mermaid_code,
-            parent_file_id=db_mindmap.source_id,
-            parent_file_key=source.s3_key if source else None,
-            created_at=db_mindmap.created_at,
-            message="Mind map generated successfully"
-        )
+        # Notify via WebSocket
+        await manager.send_result(connection_id, {
+            "type": "mindmap",
+            "id": db_mindmap.id,
+            "status": "completed",
+            "title": db_mindmap.title
+        })
 
-    except HTTPException:
-        raise
     except Exception as e:
-        logger.error(f"Mind map generation endpoint failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Background mindmap generation failed: {e}")
+        db_mindmap = db.query(db_models.MindMap).filter(db_models.MindMap.id == mindmap_id).first()
+        if db_mindmap:
+            db_mindmap.status = "failed"
+            db_mindmap.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, f"Mind map generation failed: {str(e)}")
+    finally:
+        db.close()
+
+@router.post("/generate", response_model=MindMapResponse)
+async def generate_mindmap(
+    request: MindMapGenerateRequest,
+    background_tasks: BackgroundTasks,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Initiates mind map generation in the background.
+    """
+    source_id = None
+    if request.file_key:
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        if not source:
+            raise HTTPException(status_code=403, detail="Not authorized to access this file")
+        source_id = source.id
+
+    # Create initial processing record
+    title = request.title if request.title else (request.file_key.split('/')[-1] if request.file_key else f"Mind Map {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}")
+    db_mindmap = db_models.MindMap(
+        title=title,
+        user_id=current_user.id,
+        source_id=source_id,
+        status="processing"
+    )
+    db.add(db_mindmap)
+    db.commit()
+    db.refresh(db_mindmap)
+
+    # Offload to background task
+    background_tasks.add_task(run_mindmap_generation, db_mindmap.id, request, current_user.id)
+
+    # return processing state
+    resp = MindMapResponse.model_validate(db_mindmap)
+    resp.message = "Mind map generation started"
+    return resp
 
 @router.get("/list", response_model=List[MindMapResponse])
 async def list_mindmaps(
@@ -83,17 +107,7 @@ async def list_mindmaps(
             db_models.MindMap.user_id == current_user.id
         ).order_by(db_models.MindMap.created_at.desc()).all()
         
-        return [
-            MindMapResponse(
-                id=m.id,
-                title=m.title,
-                mermaid_code=m.mermaid_code,
-                parent_file_id=m.source_id,
-                parent_file_key=m.source.s3_key if m.source else None,
-                created_at=m.created_at,
-                message="Retrieved successfully"
-            ) for m in mindmaps
-        ]
+        return [MindMapResponse.model_validate(m) for m in mindmaps]
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 

api/quizzes.py

@@ -1,102 +1,125 @@
 import logging
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Dict
+import asyncio
+from datetime import datetime
 
 from api.auth import get_current_user
 from models import db_models
 from models.schemas import QuizGenerateRequest, QuizSetResponse
-from core.database import get_db
+from core.database import get_db, SessionLocal
+from api.websocket_routes import manager
 from services.quiz_service import quiz_service
 from core import constants
 
 router = APIRouter(prefix="/api/quizzes", tags=["quizzes"])
 logger = logging.getLogger(__name__)
 
-@router.get("/config")
-async def get_quiz_config():
-    """Returns available difficulties, count options, and languages for quizzes."""
-    return {
-        "difficulties": constants.DIFFICULTIES,
-        "counts": constants.QUIZ_COUNTS,
-        "languages": constants.LANGUAGES
-    }
-
-@router.post("/generate", response_model=QuizSetResponse)
-async def generate_quiz(
-    request: QuizGenerateRequest,
-    current_user: db_models.User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    """
-    Generates a set of quiz questions and saves them to the database.
-    """
+async def run_quiz_generation(set_id: int, request: QuizGenerateRequest, user_id: int):
+    """Background task for quiz generation"""
+    db = SessionLocal()
+    connection_id = f"user_{user_id}"
     try:
-        source_id = None
-        if request.file_key:
-            source = db.query(db_models.Source).filter(
-                db_models.Source.s3_key == request.file_key,
-                db_models.Source.user_id == current_user.id
-            ).first()
-            if not source:
-                raise HTTPException(status_code=403, detail="Not authorized to access this file")
-            source_id = source.id
-
-        # 1. Generate Quiz from AI
+        db_set = db.query(db_models.QuizSet).filter(db_models.QuizSet.id == set_id).first()
+        if not db_set: return
+
+        # Call AI service
         quizzes_data = await quiz_service.generate_quiz(
             file_key=request.file_key,
             text_input=request.text_input,
             difficulty=request.difficulty,
             topic=request.topic,
             language=request.language,
-            count_mode=request.count
+            count_mode=request.count,
+            progress_callback=lambda p, m: asyncio.create_task(
+                manager.send_progress(connection_id, p, "processing", m)
+            )
         )
 
         if not quizzes_data:
-            raise HTTPException(status_code=500, detail="Failed to generate quiz")
+            raise Exception("AI failed to generate quiz questions")
 
-        # 2. Save Quiz Set
-        title = request.topic if request.topic else f"Quiz {len(quizzes_data)}"
-        db_set = db_models.QuizSet(
-            title=title,
-            difficulty=request.difficulty,
-            user_id=current_user.id,
-            source_id=source_id
-        )
-        db.add(db_set)
-        db.commit()
-        db.refresh(db_set)
-
-        # 3. Save Questions
+        # Save individual questions
         for item in quizzes_data:
             db_question = db_models.QuizQuestion(
                 quiz_set_id=db_set.id,
                 question=item.get("question", ""),
                 hint=item.get("hint", ""),
                 choices=item.get("choices", {}),
-                answer=item.get("answer", "1"),
+                answer=str(item.get("answer", "1")),
                 explanation=item.get("explanation", "")
             )
             db.add(db_question)
         
+        db_set.status = "completed"
         db.commit()
-        db.refresh(db_set)
 
-        return {
+        # Notify via WebSocket
+        await manager.send_result(connection_id, {
+            "type": "quiz",
             "id": db_set.id,
-            "title": db_set.title,
-            "difficulty": db_set.difficulty,
-            "created_at": db_set.created_at,
-            "parent_file_id": db_set.source_id,
-            "parent_file_key": source.s3_key if source else None,
-            "questions": db_set.questions
-        }
-
-    except HTTPException:
-        raise
+            "status": "completed",
+            "title": db_set.title
+        })
+
     except Exception as e:
-        logger.error(f"Quiz generation endpoint failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Background quiz generation failed: {e}")
+        db_set = db.query(db_models.QuizSet).filter(db_models.QuizSet.id == set_id).first()
+        if db_set:
+            db_set.status = "failed"
+            db_set.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, f"Quiz generation failed: {str(e)}")
+    finally:
+        db.close()
+
+@router.get("/config")
+async def get_quiz_config():
+    """Returns available difficulties, count options, and languages for quizzes."""
+    return {
+        "difficulties": constants.DIFFICULTIES,
+        "counts": constants.QUIZ_COUNTS,
+        "languages": constants.LANGUAGES
+    }
+
+@router.post("/generate", response_model=QuizSetResponse)
+async def generate_quiz(
+    request: QuizGenerateRequest,
+    background_tasks: BackgroundTasks,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Initiates quiz generation in the background.
+    """
+    source_id = None
+    if request.file_key:
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        if not source:
+            raise HTTPException(status_code=403, detail="Not authorized to access this file")
+        source_id = source.id
+
+    # Create initial processing record
+    title = request.topic if request.topic else f"Quiz {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+    db_set = db_models.QuizSet(
+        title=title,
+        difficulty=request.difficulty,
+        user_id=current_user.id,
+        source_id=source_id,
+        status="processing"
+    )
+    db.add(db_set)
+    db.commit()
+    db.refresh(db_set)
+
+    # Offload to background task
+    background_tasks.add_task(run_quiz_generation, db_set.id, request, current_user.id)
+
+    return db_set
 
 @router.get("/sets", response_model=List[QuizSetResponse])
 async def list_quiz_sets(
@@ -110,18 +133,7 @@ async def list_quiz_sets(
         sets = db.query(db_models.QuizSet).filter(
             db_models.QuizSet.user_id == current_user.id
         ).order_by(db_models.QuizSet.created_at.desc()).all()
-        return [
-            {
-                "id": s.id,
-                "title": s.title,
-                "difficulty": s.difficulty,
-                "created_at": s.created_at,
-                "parent_file_id": s.source_id,
-                "parent_file_key": s.source.s3_key if s.source else None,
-                "questions": s.questions
-            }
-            for s in sets
-        ]
+        return [QuizSetResponse.model_validate(s) for s in sets]
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -142,15 +154,7 @@ async def get_quiz_set(
     if not db_set:
         raise HTTPException(status_code=404, detail="Quiz set not found")
     
-    return {
-        "id": db_set.id,
-        "title": db_set.title,
-        "difficulty": db_set.difficulty,
-        "created_at": db_set.created_at,
-        "parent_file_id": db_set.source_id,
-        "parent_file_key": db_set.source.s3_key if db_set.source else None,
-        "questions": db_set.questions
-    }
+    return QuizSetResponse.model_validate(db_set)
 
 @router.delete("/set/{set_id}")
 async def delete_quiz_set(

api/reports.py

@@ -1,18 +1,69 @@
 import logging
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
 from sqlalchemy.orm import Session
 from typing import List, Optional
+from datetime import datetime
 
 from api.auth import get_current_user
 from models import db_models
 from models.schemas import ReportGenerateRequest, ReportResponse, ReportFormatSuggestionResponse
-from core.database import get_db
+from core.database import get_db, SessionLocal
+from api.websocket_routes import manager
 from services.report_service import report_service
 from core import constants
 
 router = APIRouter(prefix="/api/reports", tags=["reports"])
 logger = logging.getLogger(__name__)
 
+async def run_report_generation(report_id: int, request: ReportGenerateRequest, user_id: int):
+    """Background task for report generation"""
+    db = SessionLocal()
+    connection_id = f"user_{user_id}"
+    try:
+        db_report = db.query(db_models.Report).filter(db_models.Report.id == report_id).first()
+        if not db_report: return
+
+        # Call AI service
+        content = await report_service.generate_report(
+            file_key=request.file_key,
+            text_input=request.text_input,
+            format_key=request.format_key,
+            custom_prompt=request.custom_prompt,
+            language=request.language
+        )
+
+        if not content:
+            raise Exception("AI failed to generate report content")
+
+        # Extract title (usually the first line)
+        title = content.split('\n')[0].replace('#', '').strip()
+        if not title or len(title) < 3:
+            title = f"Report {request.format_key}"
+
+        db_report.title = title
+        db_report.content = content
+        db_report.status = "completed"
+        db.commit()
+
+        # Notify via WebSocket
+        await manager.send_result(connection_id, {
+            "type": "report",
+            "id": db_report.id,
+            "status": "completed",
+            "title": db_report.title
+        })
+
+    except Exception as e:
+        logger.error(f"Background report generation failed: {e}")
+        db_report = db.query(db_models.Report).filter(db_models.Report.id == report_id).first()
+        if db_report:
+            db_report.status = "failed"
+            db_report.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, f"Report generation failed: {str(e)}")
+    finally:
+        db.close()
+
 @router.get("/config")
 async def get_report_config():
     """Returns available formats and languages for report generation."""
@@ -41,63 +92,40 @@ async def suggest_formats(
 @router.post("/generate", response_model=ReportResponse)
 async def generate_report(
     request: ReportGenerateRequest,
+    background_tasks: BackgroundTasks,
     current_user: db_models.User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
     """
-    Generates a full report and saves it to the database.
+    Initiates report generation in the background.
     """
-    try:
-        source_id = None
-        if request.file_key:
-            source = db.query(db_models.Source).filter(
-                db_models.Source.s3_key == request.file_key,
-                db_models.Source.user_id == current_user.id
-            ).first()
-            if not source:
-                raise HTTPException(status_code=403, detail="Not authorized to access this file")
-            source_id = source.id
-
-        # 1. Generate Report from AI
-        content = await report_service.generate_report(
-            file_key=request.file_key,
-            text_input=request.text_input,
-            format_key=request.format_key,
-            custom_prompt=request.custom_prompt,
-            language=request.language
-        )
-
-        if not content:
-            raise HTTPException(status_code=500, detail="Failed to generate report")
-
-        # 2. Extract title (usually the first line)
-        title = content.split('\n')[0].replace('#', '').strip()
-        if not title or len(title) < 3:
-            title = f"Report {request.format_key}"
+    source_id = None
+    if request.file_key:
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        if not source:
+            raise HTTPException(status_code=403, detail="Not authorized to access this file")
+        source_id = source.id
 
-        # 3. Save to DB
-        db_report = db_models.Report(
-            title=title,
-            content=content,
-            format_key=request.format_key,
-            user_id=current_user.id,
-            source_id=source_id
-        )
-        db.add(db_report)
-        db.commit()
-        db.refresh(db_report)
+    # Create initial processing record
+    title = f"Report {request.format_key} {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+    db_report = db_models.Report(
+        title=title,
+        format_key=request.format_key,
+        user_id=current_user.id,
+        source_id=source_id,
+        status="processing"
+    )
+    db.add(db_report)
+    db.commit()
+    db.refresh(db_report)
 
-        return {
-            **db_report.__dict__,
-            "parent_file_id": db_report.source_id,
-            "parent_file_key": source.s3_key if source else None
-        }
+    # Offload to background task
+    background_tasks.add_task(run_report_generation, db_report.id, request, current_user.id)
 
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Report generation endpoint failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    return db_report
 
 @router.get("/list", response_model=List[ReportResponse])
 async def list_reports(
@@ -111,18 +139,7 @@ async def list_reports(
         reports = db.query(db_models.Report).filter(
             db_models.Report.user_id == current_user.id
         ).order_by(db_models.Report.created_at.desc()).all()
-        return [
-            {
-                "id": r.id,
-                "title": r.title,
-                "content": r.content,
-                "format_key": r.format_key,
-                "parent_file_id": r.source_id,
-                "parent_file_key": r.source.s3_key if r.source else None,
-                "created_at": r.created_at
-            }
-            for r in reports
-        ]
+        return [ReportResponse.model_validate(r) for r in reports]
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -143,15 +160,7 @@ async def get_report(
     if not report:
         raise HTTPException(status_code=404, detail="Report not found")
     
-    return {
-        "id": report.id,
-        "title": report.title,
-        "content": report.content,
-        "format_key": report.format_key,
-        "parent_file_id": report.source_id,
-        "parent_file_key": report.source.s3_key if report.source else None,
-        "created_at": report.created_at
-    }
+    return ReportResponse.model_validate(report)
 
 @router.delete("/{report_id}")
 async def delete_report(

api/video_generator.py

@@ -1,12 +1,14 @@
 import logging
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
 from sqlalchemy.orm import Session
 from typing import List
+from datetime import datetime
 
 from api.auth import get_current_user
 from models import db_models
 from models.schemas import VideoSummaryGenerateRequest, VideoSummaryResponse
-from core.database import get_db
+from core.database import get_db, SessionLocal
+from api.websocket_routes import manager
 from services.video_generator_service import video_generator_service
 from services.slides_video_service import slides_video_service
 from services.s3_service import s3_service
@@ -14,27 +16,19 @@ from services.s3_service import s3_service
 router = APIRouter(prefix="/api/videos", tags=["video-generator"])
 logger = logging.getLogger(__name__)
 
-@router.post("/generate", response_model=VideoSummaryResponse)
-async def generate_video_summary(
-    request: VideoSummaryGenerateRequest,
-    current_user: db_models.User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    """
-    Analyzes a PDF and generates a narrated video summary.
-    """
+async def run_video_generation(summary_id: int, request: VideoSummaryGenerateRequest, user_id: int):
+    """Background task for video summary generation"""
+    logger.info(f"Starting background video generation for ID: {summary_id}")
+    db = SessionLocal()
+    connection_id = f"user_{user_id}"
     try:
-        # Check source ownership
-        source = db.query(db_models.Source).filter(
-            db_models.Source.s3_key == request.file_key,
-            db_models.Source.user_id == current_user.id
-        ).first()
-        
-        if not source:
-            raise HTTPException(status_code=403, detail="Not authorized to access this file")
+        db_summary = db.query(db_models.VideoSummary).filter(db_models.VideoSummary.id == summary_id).first()
+        if not db_summary: 
+            logger.error(f"Video summary {summary_id} not found in database")
+            return
 
         if request.use_slides_transformation:
-            # Full PDF -> Slides -> Video pipeline
+            logger.info(f"Task {summary_id}: Using slides transformation pipeline")
             result = await slides_video_service.generate_transformed_video_summary(
                 file_key=request.file_key,
                 language=request.language,
@@ -42,39 +36,74 @@ async def generate_video_summary(
                 custom_prompt=request.custom_prompt
             )
         else:
-            # Standard PDF -> Video pipeline (high fidelity version)
+            logger.info(f"Task {summary_id}: Using standard video pipeline")
             result = await video_generator_service.generate_video_summary(
                 file_key=request.file_key,
                 language=request.language,
                 voice_name=request.voice_name
             )
 
-        # Save to DB
-        db_summary = db_models.VideoSummary(
-            title=result["title"],
-            s3_key=result["s3_key"],
-            s3_url=result["s3_url"],
-            user_id=current_user.id,
-            source_id=source.id
-        )
-        db.add(db_summary)
+        db_summary.title = result["title"]
+        db_summary.s3_key = result["s3_key"]
+        db_summary.s3_url = result["s3_url"]
+        db_summary.status = "completed"
         db.commit()
-        db.refresh(db_summary)
+        logger.info(f"Task {summary_id}: Successfully completed")
 
-        return {
+        # Notify via WebSocket
+        await manager.send_result(connection_id, {
+            "type": "video",
             "id": db_summary.id,
-            "title": db_summary.title,
-            "s3_key": db_summary.s3_key,
-            "public_url": db_summary.s3_url,
-            "private_url": s3_service.get_presigned_url(db_summary.s3_key),
-            "parent_file_id": db_summary.source_id,
-            "parent_file_key": db_summary.source.s3_key if db_summary.source else None,
-            "created_at": db_summary.created_at
-        }
+            "status": "completed",
+            "title": db_summary.title
+        })
 
     except Exception as e:
-        logger.error(f"Video summary endpoint failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Task {summary_id}: Background video generation failed: {e}")
+        db_summary = db.query(db_models.VideoSummary).filter(db_models.VideoSummary.id == summary_id).first()
+        if db_summary:
+            db_summary.status = "failed"
+            db_summary.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, f"Video generation failed: {str(e)}")
+    finally:
+        db.close()
+
+@router.post("/generate", response_model=VideoSummaryResponse)
+async def generate_video_summary(
+    request: VideoSummaryGenerateRequest,
+    background_tasks: BackgroundTasks,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Initiates video summary generation in the background.
+    """
+    # Check source ownership
+    source = db.query(db_models.Source).filter(
+        db_models.Source.s3_key == request.file_key,
+        db_models.Source.user_id == current_user.id
+    ).first()
+    
+    if not source:
+        raise HTTPException(status_code=403, detail="Not authorized to access this file")
+
+    # Create initial processing record
+    title = f"Video Summary {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+    db_summary = db_models.VideoSummary(
+        title=title,
+        user_id=current_user.id,
+        source_id=source.id,
+        status="processing"
+    )
+    db.add(db_summary)
+    db.commit()
+    db.refresh(db_summary)
+
+    # Offload to background task
+    background_tasks.add_task(run_video_generation, db_summary.id, request, current_user.id)
+
+    return db_summary
 
 @router.get("/list", response_model=List[VideoSummaryResponse])
 async def list_video_summaries(
@@ -89,22 +118,30 @@ async def list_video_summaries(
             db_models.VideoSummary.user_id == current_user.id
         ).order_by(db_models.VideoSummary.created_at.desc()).all()
         
-        return [
-            {
-                "id": s.id,
-                "title": s.title,
-                "s3_key": s.s3_key,
-                "public_url": s.s3_url,
-                "private_url": s3_service.get_presigned_url(s.s3_key),
-                "parent_file_id": s.source_id,
-                "parent_file_key": s.source.s3_key if s.source else None,
-                "created_at": s.created_at
-            }
-            for s in summaries
-        ]
+        return [VideoSummaryResponse.model_validate(s) for s in summaries]
     except Exception as e:
+        logger.error(f"Failed to list video summaries: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
+@router.get("/{video_id}", response_model=VideoSummaryResponse)
+async def get_video_summary(
+    video_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Retrieves a specific video summary.
+    """
+    summary = db.query(db_models.VideoSummary).filter(
+        db_models.VideoSummary.id == video_id,
+        db_models.VideoSummary.user_id == current_user.id
+    ).first()
+    
+    if not summary:
+        raise HTTPException(status_code=404, detail="Video summary not found")
+    
+    return VideoSummaryResponse.model_validate(summary)
+
 @router.delete("/{video_id}")
 async def delete_video_summary(
     video_id: int,

api/websocket_routes.py

@@ -15,6 +15,8 @@ from services.mindmap_service import mindmap_service
 from services.podcast_service import podcast_service
 from services.s3_service import s3_service
 from services.video_generator_service import video_generator_service
+from services.slides_video_service import slides_video_service
+from models.schemas import VideoSummaryGenerateRequest, ReportGenerateRequest, MindMapGenerateRequest
 
 router = APIRouter(prefix="/ws", tags=["websockets"])
 logger = logging.getLogger(__name__)
@@ -107,11 +109,14 @@ async def unified_generate_ws(
         if task_type == "podcast":
             await handle_podcast_task(connection_id, data, current_user, db)
         
-        elif task_type == "flashcards":
-            await handle_flashcards_task(connection_id, data, current_user, db)
+        elif task_type == "video":
+            await handle_video_task(connection_id, data, current_user, db)
             
-        elif task_type == "quiz":
-            await handle_quiz_task(connection_id, data, current_user, db)
+        elif task_type == "report":
+            await handle_report_task(connection_id, data, current_user, db)
+            
+        elif task_type == "mindmap":
+            await handle_mindmap_task(connection_id, data, current_user, db)
             
         else:
             await manager.send_error(connection_id, f"Unsupported task type: {task_type}")
@@ -243,6 +248,19 @@ async def handle_flashcards_task(connection_id: str, data: Dict, current_user: d
                 return
             source_id = source.id
         
+        # Create initial processing record
+        title = data.get("topic") if data.get("topic") else f"Flashcards {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+        db_set = db_models.FlashcardSet(
+            title=title,
+            difficulty=data.get("difficulty", "medium"),
+            user_id=current_user.id,
+            source_id=source_id,
+            status="processing"
+        )
+        db.add(db_set)
+        db.commit()
+        db.refresh(db_set)
+        
         await manager.send_progress(connection_id, 10, "processing", "Generating flashcards...")
         
         cards_data = await flashcard_service.generate_flashcards(
@@ -258,22 +276,10 @@ async def handle_flashcards_task(connection_id: str, data: Dict, current_user: d
         )
         
         if not cards_data:
-            await manager.send_error(connection_id, "AI returned an empty response")
-            return
+            raise Exception("AI returned empty flashcard data")
         
         await manager.send_progress(connection_id, 85, "processing", "Saving to database...")
         
-        title = data.get("topic", f"Flashcards {len(cards_data)}")
-        db_set = db_models.FlashcardSet(
-            title=title,
-            difficulty=data.get("difficulty", "medium"),
-            user_id=current_user.id,
-            source_id=source_id
-        )
-        db.add(db_set)
-        db.commit()
-        db.refresh(db_set)
-        
         for item in cards_data:
             db_card = db_models.Flashcard(
                 flashcard_set_id=db_set.id,
@@ -282,16 +288,21 @@ async def handle_flashcards_task(connection_id: str, data: Dict, current_user: d
             )
             db.add(db_card)
         
+        db_set.status = "completed"
         db.commit()
-        db.refresh(db_set)
         
         await manager.send_result(connection_id, {
             "id": db_set.id,
             "title": db_set.title,
-            "flashcards_count": len(db_set.flashcards)
+            "flashcards_count": len(db_set.flashcards),
+            "status": "completed"
         })
     except Exception as e:
         logger.error(f"Flashcard task failed: {e}")
+        if 'db_set' in locals():
+            db_set.status = "failed"
+            db_set.error_message = str(e)
+            db.commit()
         await manager.send_error(connection_id, str(e))
 
 async def handle_quiz_task(connection_id: str, data: Dict, current_user: db_models.User, db: Session):
@@ -308,6 +319,19 @@ async def handle_quiz_task(connection_id: str, data: Dict, current_user: db_mode
                 return
             source_id = source.id
         
+        # Create initial processing record
+        title = data.get("topic") if data.get("topic") else f"Quiz {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
+        db_set = db_models.QuizSet(
+            title=title,
+            difficulty=data.get("difficulty", "medium"),
+            user_id=current_user.id,
+            source_id=source_id,
+            status="processing"
+        )
+        db.add(db_set)
+        db.commit()
+        db.refresh(db_set)
+
         await manager.send_progress(connection_id, 10, "processing", "Generating quiz...")
         
         quizzes_data = await quiz_service.generate_quiz(
@@ -323,32 +347,197 @@ async def handle_quiz_task(connection_id: str, data: Dict, current_user: db_mode
         )
         
         if not quizzes_data:
-            await manager.send_error(connection_id, "Failed to generate quiz")
-            return
-        
-        db_set = db_models.QuizSet(
-            title=data.get("topic", "Quiz"),
-            difficulty=data.get("difficulty", "medium"),
-            user_id=current_user.id,
-            source_id=source_id
-        )
-        db.add(db_set)
-        db.commit()
-        db.refresh(db_set)
+            raise Exception("AI failed to generate quiz data")
         
         for item in quizzes_data:
             db_question = db_models.QuizQuestion(
                 quiz_set_id=db_set.id,
                 question=item.get("question", ""),
                 choices=item.get("choices", {}),
-                answer=item.get("answer", "1"),
+                answer=str(item.get("answer", "1")),
                 explanation=item.get("explanation", "")
             )
             db.add(db_question)
         
+        db_set.status = "completed"
         db.commit()
-        await manager.send_result(connection_id, {"id": db_set.id, "title": db_set.title})
+        await manager.send_result(connection_id, {"id": db_set.id, "title": db_set.title, "status": "completed"})
     except Exception as e:
         logger.error(f"Quiz task failed: {e}")
+        if 'db_set' in locals():
+            db_set.status = "failed"
+            db_set.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, str(e))
+
+async def handle_video_task(connection_id: str, data: Dict, current_user: db_models.User, db: Session):
+    """Internal handler for video summary generation"""
+    try:
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == data.get("file_key"),
+            db_models.Source.user_id == current_user.id
+        ).first()
+        if not source:
+            await manager.send_error(connection_id, "Not authorized to access this file")
+            return
+
+        db_summary = db_models.VideoSummary(
+            title=f"Video Summary {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}",
+            user_id=current_user.id,
+            source_id=source.id,
+            status="processing"
+        )
+        db.add(db_summary)
+        db.commit()
+        db.refresh(db_summary)
+
+        await manager.send_progress(connection_id, 10, "processing", "Starting video generation...")
+
+        if data.get("use_slides_transformation", True):
+            result = await slides_video_service.generate_transformed_video_summary(
+                file_key=data["file_key"],
+                language=data.get("language", "Japanese"),
+                voice_name=data.get("voice_name", "Kore"),
+                custom_prompt=data.get("custom_prompt", "")
+            )
+        else:
+            result = await video_generator_service.generate_video_summary(
+                file_key=data["file_key"],
+                language=data.get("language", "Japanese"),
+                voice_name=data.get("voice_name", "Kore")
+            )
+
+        db_summary.title = result["title"]
+        db_summary.s3_key = result["s3_key"]
+        db_summary.s3_url = result["s3_url"]
+        db_summary.status = "completed"
+        db.commit()
+
+        await manager.send_result(connection_id, {
+            "type": "video",
+            "id": db_summary.id,
+            "status": "completed",
+            "title": db_summary.title,
+            "public_url": db_summary.s3_url
+        })
+    except Exception as e:
+        logger.error(f"Video task failed: {e}")
+        if 'db_summary' in locals():
+            db_summary.status = "failed"
+            db_summary.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, str(e))
+
+async def handle_report_task(connection_id: str, data: Dict, current_user: db_models.User, db: Session):
+    """Internal handler for report generation"""
+    try:
+        source_id = None
+        if data.get("file_key"):
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == data["file_key"],
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                await manager.send_error(connection_id, "Not authorized to access this file")
+                return
+            source_id = source.id
+
+        db_report = db_models.Report(
+            title=f"Report {data.get('format_key', 'custom')} {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}",
+            format_key=data.get("format_key", "custom"),
+            user_id=current_user.id,
+            source_id=source_id,
+            status="processing"
+        )
+        db.add(db_report)
+        db.commit()
+        db.refresh(db_report)
+
+        await manager.send_progress(connection_id, 15, "processing", "Generating report content...")
+
+        content = await report_service.generate_report(
+            file_key=data.get("file_key"),
+            text_input=data.get("text_input"),
+            format_key=data.get("format_key", "briefing_doc"),
+            custom_prompt=data.get("custom_prompt"),
+            language=data.get("language", "Japanese")
+        )
+
+        if not content:
+            raise Exception("AI failed to generate report content")
+
+        title = content.split('\n')[0].replace('#', '').strip()
+        if not title or len(title) < 3:
+            title = f"Report {data.get('format_key')}"
+
+        db_report.title = title
+        db_report.content = content
+        db_report.status = "completed"
+        db.commit()
+
+        await manager.send_result(connection_id, {
+            "type": "report",
+            "id": db_report.id,
+            "status": "completed",
+            "title": db_report.title
+        })
+    except Exception as e:
+        logger.error(f"Report task failed: {e}")
+        if 'db_report' in locals():
+            db_report.status = "failed"
+            db_report.error_message = str(e)
+            db.commit()
+        await manager.send_error(connection_id, str(e))
+
+async def handle_mindmap_task(connection_id: str, data: Dict, current_user: db_models.User, db: Session):
+    """Internal handler for mindmap generation"""
+    try:
+        source_id = None
+        if data.get("file_key"):
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == data["file_key"],
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                await manager.send_error(connection_id, "Not authorized to access this file")
+                return
+            source_id = source.id
+
+        db_mindmap = db_models.MindMap(
+            title=data.get("title") if data.get("title") else f"Mind Map {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}",
+            user_id=current_user.id,
+            source_id=source_id,
+            status="processing"
+        )
+        db.add(db_mindmap)
+        db.commit()
+        db.refresh(db_mindmap)
+
+        await manager.send_progress(connection_id, 20, "processing", "Generating mind map visualization...")
+
+        mermaid_code = await mindmap_service.generate_mindmap(
+            file_key=data.get("file_key"),
+            text_input=data.get("text_input")
+        )
+
+        if not mermaid_code:
+            raise Exception("AI failed to generate mind map code")
+
+        db_mindmap.mermaid_code = mermaid_code
+        db_mindmap.status = "completed"
+        db.commit()
+
+        await manager.send_result(connection_id, {
+            "type": "mindmap",
+            "id": db_mindmap.id,
+            "status": "completed",
+            "title": db_mindmap.title
+        })
+    except Exception as e:
+        logger.error(f"Mindmap task failed: {e}")
+        if 'db_mindmap' in locals():
+            db_mindmap.status = "failed"
+            db_mindmap.error_message = str(e)
+            db.commit()
         await manager.send_error(connection_id, str(e))
 

models/db_models.py

@@ -63,6 +63,15 @@ class Podcast(Base):
     def parent_file_key(self):
         return self.source.s3_key if self.source else None
 
+    @property
+    def public_url(self):
+        return self.s3_url
+
+    @property
+    def private_url(self):
+        from services.s3_service import s3_service
+        return s3_service.get_presigned_url(self.s3_key) if self.s3_key else None
+
 
 class FlashcardSet(Base):
     __tablename__ = "flashcard_sets"
@@ -72,25 +81,37 @@ class FlashcardSet(Base):
     difficulty = Column(String(50))
     user_id = Column(Integer, ForeignKey("users.id"))
     source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    status = Column(String(50), default="processing")
+    error_message = Column(UnicodeText, nullable=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     owner = relationship("User", back_populates="flashcard_sets")
     source = relationship("Source", back_populates="flashcard_sets")
     flashcards = relationship("Flashcard", back_populates="flashcard_set", cascade="all, delete-orphan")
 
+    @property
+    def parent_file_key(self):
+        return self.source.s3_key if self.source else None
+
 class MindMap(Base):
     __tablename__ = "mind_maps"
 
     id = Column(Integer, primary_key=True, index=True)
     title = Column(Unicode(255))
-    mermaid_code = Column(UnicodeText, nullable=False)
+    mermaid_code = Column(UnicodeText, nullable=True)
     user_id = Column(Integer, ForeignKey("users.id"))
     source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    status = Column(String(50), default="processing")
+    error_message = Column(UnicodeText, nullable=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     owner = relationship("User", back_populates="mind_maps")
     source = relationship("Source", back_populates="mind_maps")
 
+    @property
+    def parent_file_key(self):
+        return self.source.s3_key if self.source else None
+
 class QuizSet(Base):
     __tablename__ = "quiz_sets"
 
@@ -99,12 +120,18 @@ class QuizSet(Base):
     difficulty = Column(String(50))
     user_id = Column(Integer, ForeignKey("users.id"))
     source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    status = Column(String(50), default="processing")
+    error_message = Column(UnicodeText, nullable=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     owner = relationship("User", back_populates="quiz_sets")
     source = relationship("Source", back_populates="quiz_sets")
     questions = relationship("QuizQuestion", back_populates="quiz_set", cascade="all, delete-orphan")
 
+    @property
+    def parent_file_key(self):
+        return self.source.s3_key if self.source else None
+
 class QuizQuestion(Base):
     __tablename__ = "quiz_questions"
 
@@ -123,29 +150,50 @@ class Report(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     title = Column(Unicode(255))
-    content = Column(UnicodeText, nullable=False)
+    content = Column(UnicodeText, nullable=True)
     format_key = Column(String(100))
     user_id = Column(Integer, ForeignKey("users.id"))
     source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    status = Column(String(50), default="processing")
+    error_message = Column(UnicodeText, nullable=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     owner = relationship("User", back_populates="reports")
     source = relationship("Source", back_populates="reports")
 
+    @property
+    def parent_file_key(self):
+        return self.source.s3_key if self.source else None
+
 class VideoSummary(Base):
     __tablename__ = "video_summaries"
 
     id = Column(Integer, primary_key=True, index=True)
     title = Column(Unicode(255))
-    s3_key = Column(String(512), nullable=False)
-    s3_url = Column(String(1024), nullable=False)
+    s3_key = Column(String(512), nullable=True)
+    s3_url = Column(String(1024), nullable=True)
     user_id = Column(Integer, ForeignKey("users.id"))
     source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    status = Column(String(50), default="processing")
+    error_message = Column(UnicodeText, nullable=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     owner = relationship("User", back_populates="video_summaries")
     source = relationship("Source", back_populates="video_summaries")
 
+    @property
+    def parent_file_key(self):
+        return self.source.s3_key if self.source else None
+
+    @property
+    def public_url(self):
+        return self.s3_url
+
+    @property
+    def private_url(self):
+        from services.s3_service import s3_service
+        return s3_service.get_presigned_url(self.s3_key) if self.s3_key else None
+
 class Flashcard(Base):
     __tablename__ = "flashcards"
 

models/schemas.py

@@ -62,7 +62,7 @@ class PodcastResponse(BaseModel):
     s3_key: Optional[str]
     s3_url: Optional[str]
     script: Optional[str]
-    status: str = "completed"
+    status: Optional[str] = "completed"
     error_message: Optional[str]
     parent_file_id: Optional[int] = None
     parent_file_key: Optional[str] = None
@@ -90,14 +90,19 @@ class FlashcardResponse(BaseModel):
     question: str
     answer: str
 
+    class Config:
+        from_attributes = True
+
 class FlashcardSetResponse(BaseModel):
     id: int
     title: Optional[str]
     difficulty: str
+    status: Optional[str] = "completed"
+    error_message: Optional[str] = None
     created_at: datetime
     parent_file_id: Optional[int] = None
     parent_file_key: Optional[str] = None
-    flashcards: List[FlashcardResponse]
+    flashcards: List[FlashcardResponse] = []
 
     class Config:
         from_attributes = True
@@ -111,11 +116,16 @@ class MindMapGenerateRequest(BaseModel):
 class MindMapResponse(BaseModel):
     id: Optional[int] = None
     title: str
-    mermaid_code: str
+    mermaid_code: Optional[str] = None
+    status: Optional[str] = "completed"
+    error_message: Optional[str] = None
     parent_file_id: Optional[int] = None
     parent_file_key: Optional[str] = None
     created_at: Optional[datetime] = None
-    message: str
+    message: Optional[str] = None
+
+    class Config:
+        from_attributes = True
 
 # Quiz Schemas
 class QuizGenerateRequest(BaseModel):
@@ -134,14 +144,19 @@ class QuizQuestionResponse(BaseModel):
     answer: str
     explanation: Optional[str]
 
+    class Config:
+        from_attributes = True
+
 class QuizSetResponse(BaseModel):
     id: int
     title: Optional[str]
     difficulty: str
+    status: Optional[str] = "completed"
+    error_message: Optional[str] = None
     created_at: datetime
     parent_file_id: Optional[int] = None
     parent_file_key: Optional[str] = None
-    questions: List[QuizQuestionResponse]
+    questions: List[QuizQuestionResponse] = []
 
     class Config:
         from_attributes = True
@@ -165,8 +180,10 @@ class ReportGenerateRequest(BaseModel):
 class ReportResponse(BaseModel):
     id: int
     title: str
-    content: str
+    content: Optional[str] = None
     format_key: str
+    status: Optional[str] = "completed"
+    error_message: Optional[str] = None
     parent_file_id: Optional[int] = None
     parent_file_key: Optional[str] = None
     created_at: datetime
@@ -185,9 +202,11 @@ class VideoSummaryGenerateRequest(BaseModel):
 class VideoSummaryResponse(BaseModel):
     id: int
     title: str
-    s3_key: str
-    public_url: str
+    s3_key: Optional[str] = None
+    public_url: Optional[str] = None
     private_url: Optional[str] = None
+    status: Optional[str] = "completed"
+    error_message: Optional[str] = None
     parent_file_id: Optional[int] = None
     parent_file_key: Optional[str] = None
     created_at: datetime

services/slides_video_service.py

@@ -1,6 +1,6 @@
 import json
+import asyncio
 from typing import Dict, List, Optional, Any, Tuple
-import logging
 import os
 import tempfile
 import time
@@ -10,7 +10,7 @@ import re
 import wave
 import yaml
 import requests
-import openai
+from openai import AsyncOpenAI
 from google.cloud import storage
 from googleapiclient.discovery import build
 from googleapiclient.http import MediaIoBaseUpload
@@ -31,8 +31,6 @@ from core.prompts import (
 )
 from services.s3_service import s3_service
 
-logger = logging.getLogger(__name__)
-
 # Constants from temp project
 TEMPLATE_HINT: Dict[str, str] = {
     "cover": "COVER.MAIN",
@@ -49,10 +47,10 @@ TEMPLATE_HINT: Dict[str, str] = {
 
 class SlidesVideoService:
     def __init__(self):
-        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+        self.openai_client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
         
         # Match Temp project: Use API Key for Gemini TTS
-        logger.info("Initializing Gemini Client with API Key for Slides (as in Temp project)")
+        print("[SlidesVideo] Initializing Gemini Client with API Key")
         self.gemini_client = genai.Client(api_key=settings.GEMINI_API_KEY)
 
         self.scopes = [
@@ -61,18 +59,11 @@ class SlidesVideoService:
         ]
 
     def _get_sa_info(self) -> Optional[Dict[str, Any]]:
-        """Parse GCP_SA_JSON - matches original Temp project logic exactly."""
         sa_json = os.environ.get("GCP_SA_JSON") or os.environ.get("GCS_SA_JSON")
-        if not sa_json:
-            return None
-        # Just parse it directly like the original
+        if not sa_json: return None
         return json.loads(sa_json)
 
     def _get_google_creds(self):
-        """
-        Builds Google credentials from environment variables.
-        Matches Temp project logic.
-        """
         token_json = settings.GOOGLE_OAUTH_TOKEN_JSON
         if token_json:
             creds = Credentials.from_authorized_user_info(json.loads(token_json), self.scopes)
@@ -83,8 +74,7 @@ class SlidesVideoService:
         info = self._get_sa_info()
         if info:
             return service_account.Credentials.from_service_account_info(info, scopes=self.scopes)
-        
-        raise RuntimeError("Google API credentials not configured (GOOGLE_OAUTH_TOKEN_JSON or GCP_SA_JSON required)")
+        raise RuntimeError("Google API credentials not configured")
 
     def _get_clients(self):
         creds = self._get_google_creds()
@@ -93,12 +83,18 @@ class SlidesVideoService:
         return slides, drive
 
     async def extract_text_from_pdf(self, pdf_path: str) -> str:
-        """Extract text from PDF using OpenAI."""
+        """Extract text from PDF using Native Async OpenAI."""
+        print("[SlidesVideo] Extracting text from PDF via OpenAI...")
         with open(pdf_path, "rb") as f:
-            openai_file = self.openai_client.files.create(file=f, purpose="assistants")
+            content = f.read()
+            
+        openai_file = await self.openai_client.files.create(
+            file=("source.pdf", content), 
+            purpose="assistants"
+        )
         
         prompt = get_pdf_text_extraction_prompt()
-        response = self.openai_client.chat.completions.create(
+        response = await self.openai_client.chat.completions.create(
             model="gpt-4o-mini",
             messages=[
                 {
@@ -109,14 +105,14 @@ class SlidesVideoService:
             temperature=0
         )
         text = response.choices[0].message.content
-        self.openai_client.files.delete(openai_file.id)
+        await self.openai_client.files.delete(openai_file.id)
         return text
 
     async def generate_outline(self, source_text: str, language: str = "Japanese", custom_prompt: str = "") -> Dict[str, Any]:
-        """Step 1: Generate Slide Outline (JSON) from text."""
+        """Step 1: Generate Slide Outline (JSON) from text via Native Async OpenAI."""
+        print("[SlidesVideo] Generating slide outline...")
         template_path = "core/templates/ja_slide_template.yaml" if language == "Japanese" else "core/templates/eng_slide_template.yaml"
         if not os.path.exists(template_path):
-            # Fallback if I missed copying
             template_path = f"Temp/AI-Video-Summary-Generator/{'ja' if language == 'Japanese' else 'eng'}_slide_template.yaml"
         
         with open(template_path, "r", encoding="utf-8") as f:
@@ -124,7 +120,7 @@ class SlidesVideoService:
 
         prompt = get_outline_prompt(template_yaml, source_text, custom_prompt, language)
         
-        response = self.openai_client.chat.completions.create(
+        response = await self.openai_client.chat.completions.create(
             model="gpt-4o-mini",
             messages=[{"role": "user", "content": prompt}],
             temperature=0.2,
@@ -133,55 +129,39 @@ class SlidesVideoService:
         return json.loads(response.choices[0].message.content)
 
     async def create_slides_and_export_pdf(self, outline: Dict[str, Any], template_filename: str = "slide_template_v001.pptx") -> bytes:
-        """Step 2 & 3: Create Google Slides and export to PDF."""
-        slides_api, drive_api = self._get_clients()
-        
-        # 1. Get Template: Try local first, then GCS
-        pptx_path = os.path.join("core", "templates", template_filename)
-        if os.path.exists(pptx_path):
-            with open(pptx_path, "rb") as f:
-                pptx_bytes = f.read()
-        else:
-            logger.info(f"Template {template_filename} not found locally, trying GCS...")
-            try:
-                pptx_bytes = self._download_template_from_gcs(template_filename)
-            except Exception as e:
-                raise FileNotFoundError(f"Template {template_filename} not found locally or on GCS: {e}")
-
-        # 2. Upload and convert
-        media = MediaIoBaseUpload(io.BytesIO(pptx_bytes), mimetype="application/vnd.openxmlformats-officedocument.presentationml.presentation")
-        body = {
-            "name": f"Generated Video Source {int(time.time())}",
-            "mimeType": "application/vnd.google-apps.presentation",
-        }
-        
-        folder_id = os.environ.get("DRIVE_FOLDER_ID")
-        if folder_id:
-            body["parents"] = [folder_id]
+        """Step 2 & 3: Create Google Slides (Sync inside to_thread)."""
+        def _execute():
+            print("[SlidesVideo] Interacting with Google Slides API...")
+            slides_api, drive_api = self._get_clients()
             
-        created = drive_api.files().create(body=body, media_body=media, supportsAllDrives=True, fields="id").execute()
-        pres_id = created["id"]
+            pptx_path = os.path.join("core", "templates", template_filename)
+            if os.path.exists(pptx_path):
+                with open(pptx_path, "rb") as f:
+                    pptx_bytes = f.read()
+            else:
+                pptx_bytes = self._download_template_from_gcs(template_filename)
+
+            media = MediaIoBaseUpload(io.BytesIO(pptx_bytes), mimetype="application/vnd.openxmlformats-officedocument.presentationml.presentation")
+            body = {
+                "name": f"Generated Video Source {int(time.time())}",
+                "mimeType": "application/vnd.google-apps.presentation",
+            }
+            folder_id = os.environ.get("DRIVE_FOLDER_ID")
+            if folder_id: body["parents"] = [folder_id]
+                
+            created = drive_api.files().create(body=body, media_body=media, supportsAllDrives=True, fields="id").execute()
+            pres_id = created["id"]
 
-        try:
-            # 3. Build slides from outline
-            self._build_from_outline(slides_api, pres_id, outline)
-            
-            # 4. Export to PDF
-            pdf_bytes = drive_api.files().export(
-                fileId=pres_id,
-                mimeType="application/pdf",
-            ).execute()
-            
-            return pdf_bytes
-        finally:
-            # Cleanup temp presentation
             try:
-                drive_api.files().delete(fileId=pres_id).execute()
-            except:
-                pass
+                self._build_from_outline(slides_api, pres_id, outline)
+                pdf_bytes = drive_api.files().export(fileId=pres_id, mimeType="application/pdf").execute()
+                return pdf_bytes
+            finally:
+                try: drive_api.files().delete(fileId=pres_id).execute()
+                except: pass
+        return await asyncio.to_thread(_execute)
 
     def _build_from_outline(self, slides, pres_id, outline):
-        """Port of build_from_outline from temp project."""
         items = outline.get("slides", [])
         initial = slides.presentations().get(presentationId=pres_id).execute()
         original_page_ids = [p["objectId"] for p in initial.get("slides", [])]
@@ -189,33 +169,23 @@ class SlidesVideoService:
         for item in items:
             tpl = item.get("template", "")
             fields = item.get("fields", {})
-            
-            # Find base page
             rep_key = TEMPLATE_HINT.get(tpl) or next(iter(fields.keys()), "")
             base_page = self._find_page(slides, pres_id, rep_key)
             if not base_page: continue
 
-            # Duplicate
             resp = slides.presentations().batchUpdate(
                 presentationId=pres_id,
                 body={"requests": [{"duplicateObject": {"objectId": base_page}}]}
             ).execute()
             new_page = resp["replies"][0]["duplicateObject"]["objectId"]
 
-            # Move to end
             pres_detail = slides.presentations().get(presentationId=pres_id).execute()
             insertion_index = max(0, len(pres_detail.get("slides", [])) - 1)
             slides.presentations().batchUpdate(
                 presentationId=pres_id,
-                body={"requests": [{
-                    "updateSlidesPosition": {
-                        "slideObjectIds": [new_page],
-                        "insertionIndex": insertion_index
-                    }
-                }]}
+                body={"requests": [{"updateSlidesPosition": {"slideObjectIds": [new_page], "insertionIndex": insertion_index}}]}
             ).execute()
 
-            # Replace text
             reqs = []
             for k, v in fields.items():
                 reqs.append({
@@ -228,39 +198,25 @@ class SlidesVideoService:
             if reqs:
                 slides.presentations().batchUpdate(presentationId=pres_id, body={"requests": reqs}).execute()
 
-            # Cleanup unused placeholders {{...}} on this slide (Matches original implementation)
-            try:
-                self._cleanup_placeholders(slides, pres_id, new_page, fields)
-            except Exception as e:
-                logger.warning(f"Placeholder cleanup failed for slide {new_page}: {e}")
+            try: self._cleanup_placeholders(slides, pres_id, new_page, fields)
+            except: pass
 
-        # Delete originals
         if original_page_ids:
             reqs = [{"deleteObject": {"objectId": pid}} for pid in original_page_ids]
             slides.presentations().batchUpdate(presentationId=pres_id, body={"requests": reqs}).execute()
 
     def _cleanup_placeholders(self, slides, pres_id, page_id, fields):
-        """Finds all remaining {{TAGS}} and replaces them with empty strings."""
         pres = slides.presentations().get(presentationId=pres_id).execute()
         slide = next(s for s in pres.get("slides", []) if s.get("objectId") == page_id)
-        
         found_tags = set()
         for el in slide.get("pageElements", []):
             text = el.get("shape", {}).get("text", {})
             for te in text.get("textElements", []):
                 content = te.get("textRun", {}).get("content", "")
-                for m in re.findall(r"\{\{([A-Z0-9_.-]+)\}\}", content):
-                    found_tags.add(m)
-        
+                for m in re.findall(r"\{\{([A-Z0-9_.-]+)\}\}", content): found_tags.add(m)
         unused = [t for t in found_tags if t not in fields]
         if unused:
-            reqs = [{
-                "replaceAllText": {
-                    "containsText": {"text": f"{{{{{t}}}}}", "matchCase": True},
-                    "replaceText": "",
-                    "pageObjectIds": [page_id]
-                }
-            } for t in unused]
+            reqs = [{"replaceAllText": {"containsText": {"text": f"{{{{{t}}}}}", "matchCase": True}, "replaceText": "", "pageObjectIds": [page_id]}} for t in unused]
             slides.presentations().batchUpdate(presentationId=pres_id, body={"requests": reqs}).execute()
 
     def _find_page(self, slides, pres_id, placeholder_key):
@@ -270,59 +226,50 @@ class SlidesVideoService:
             for el in page.get("pageElements", []):
                 text = el.get("shape", {}).get("text", {})
                 for te in text.get("textElements", []):
-                    if needle in te.get("textRun", {}).get("content", ""):
-                        return page["objectId"]
+                    if needle in te.get("textRun", {}).get("content", ""): return page["objectId"]
         return None
 
     def _download_template_from_gcs(self, filename: str) -> bytes:
-        """Download template from GCS bucket (mimics Temp project logic)."""
         bucket_name = settings.GCS_BUCKET
-        if not bucket_name:
-            raise RuntimeError("GCS_BUCKET environment variable is missing")
-        
-        # Path in bucket from Temp project: templates/filename
+        if not bucket_name: raise RuntimeError("GCS_BUCKET missing")
         object_name = f"templates/{filename}"
-        
-        # Use SA if available, else default
         info = self._get_sa_info()
         if info:
             creds = service_account.Credentials.from_service_account_info(info)
             client = storage.Client(project=info.get("project_id"), credentials=creds)
         else:
             client = storage.Client()
-            
         bucket = client.bucket(bucket_name)
         blob = bucket.blob(object_name)
         return blob.download_as_bytes()
 
-    async def generate_video_from_pdf_bytes(
-        self, 
-        pdf_bytes: bytes, 
-        language: str = "Japanese", 
-        voice_name: str = "Kore"
-    ) -> Dict[str, Any]:
-        """Step 4, 5, 6: PDF bytes -> Video Pipeline."""
+    async def generate_video_from_pdf_bytes(self, pdf_bytes: bytes, language: str = "Japanese", voice_name: str = "Kore") -> Dict[str, Any]:
+        """Step 4, 5, 6: PDF bytes -> Video Pipeline using Async Gemini and Threads."""
         temp_dir = tempfile.mkdtemp(prefix="video_final_")
         try:
             pdf_path = os.path.join(temp_dir, "source.pdf")
-            with open(pdf_path, "wb") as f:
-                f.write(pdf_bytes)
+            with open(pdf_path, "wb") as f: f.write(pdf_bytes)
 
             # 1. Images
-            images = convert_from_path(pdf_path, dpi=200)
+            print("[SlidesVideo] Converting PDF to images...")
+            images = await asyncio.to_thread(convert_from_path, pdf_path, dpi=200)
             total_pages = len(images)
             image_paths = []
             for i, img in enumerate(images, start=1):
-                p = os.path.join(temp_dir, f"p_{i:02d}.png")
-                img.save(p, "PNG")
-                image_paths.append(p)
+                p = os.path.join(temp_dir, f"p_{i:02d}.png"); img.save(p, "PNG"); image_paths.append(p)
 
             # 2. Narration Script
+            print(f"[SlidesVideo] Generating script via OpenAI for {total_pages} pages...")
             with open(pdf_path, "rb") as f:
-                openai_file = self.openai_client.files.create(file=f, purpose="assistants")
+                content = f.read()
+                
+            openai_file = await self.openai_client.files.create(
+                file=("source.pdf", content), 
+                purpose="assistants"
+            )
             
             prompt = get_video_script_prompt(language, total_pages)
-            resp = self.openai_client.chat.completions.create(
+            resp = await self.openai_client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[{"role": "user", "content": [{"type": "text", "text": prompt}, {"type": "file", "file": {"file_id": openai_file.id}}]}],
                 response_format={"type": "json_object"},
@@ -330,133 +277,76 @@ class SlidesVideoService:
             )
             script_data = json.loads(resp.choices[0].message.content)
             scripts = script_data.get("scripts", [])
-            self.openai_client.files.delete(openai_file.id)
+            await self.openai_client.files.delete(openai_file.id)
 
-            # 3. Audio & Video assembly (similar to existing logic but more refined)
+            # 3. Audio & Video Assembly
             page_clips = []
             target_size = (1920, 1080)
-            
             for i, img_path in enumerate(image_paths):
-                # Skip last slide narration if it's the logo slide (standard logic in temp project)
                 if i < len(scripts) and i < len(image_paths) - 1:
                     text = scripts[i].get("script_text", "")
                     audio_path = os.path.join(temp_dir, f"a_{i}.wav")
-                    
-                    # TTS with fallback
+                    print(f"[SlidesVideo] Generating TTS for slide {i}...")
                     try:
-                        model_name = "gemini-2.5-flash-preview-tts"
-                        logger.info(f"Generating audio for slide {i} using {model_name}...")
-                        tts_resp = self.gemini_client.models.generate_content(
-                            model=model_name,
+                        tts_resp = await self.gemini_client.aio.models.generate_content(
+                            model="gemini-2.5-flash-preview-tts",
                             contents=text,
                             config=types.GenerateContentConfig(
                                 response_modalities=["AUDIO"],
-                                speech_config=types.SpeechConfig(
-                                    voice_config=types.VoiceConfig(
-                                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                                            voice_name=voice_name
-                                        )
-                                    )
-                                )
+                                speech_config=types.SpeechConfig(voice_config=types.VoiceConfig(prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=voice_name)))
                             )
                         )
-                    except Exception as tts_err:
-                        logger.warning(f"Failed with {model_name}, trying fallback gemini-1.5-flash: {tts_err}")
-                        model_name = "gemini-1.5-flash"
-                        tts_resp = self.gemini_client.models.generate_content(
-                            model=model_name,
+                    except Exception as e:
+                        print(f"[SlidesVideo] TTS fallback used for slide {i}: {e}")
+                        tts_resp = await self.gemini_client.aio.models.generate_content(
+                            model="gemini-1.5-flash",
                             contents=text,
                             config=types.GenerateContentConfig(
                                 response_modalities=["AUDIO"],
-                                speech_config=types.SpeechConfig(
-                                    voice_config=types.VoiceConfig(
-                                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                                            voice_name=voice_name
-                                        )
-                                    )
-                                )
+                                speech_config=types.SpeechConfig(voice_config=types.VoiceConfig(prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=voice_name)))
                             )
                         )
                     audio_data = tts_resp.candidates[0].content.parts[0].inline_data.data
-                    with wave.open(audio_path, "wb") as wf:
-                        wf.setnchannels(1); wf.setsampwidth(2); wf.setframerate(24000); wf.writeframes(audio_data)
+                    with wave.open(audio_path, "wb") as wf: wf.setnchannels(1); wf.setsampwidth(2); wf.setframerate(24000); wf.writeframes(audio_data)
                     
                     aud_clip = AudioFileClip(audio_path)
-                    duration = aud_clip.duration
-                    img_clip = ImageClip(self._prepare_img(img_path, target_size, temp_dir, i), duration=duration)
+                    img_clip = ImageClip(self._prepare_img(img_path, target_size, temp_dir, i), duration=aud_clip.duration)
                     page_clips.append(img_clip.with_audio(aud_clip))
-                    time.sleep(2)
+                    await asyncio.sleep(2)
                 else:
-                    # Silent 3s for last slide or missing scripts
-                    img_clip = ImageClip(self._prepare_img(img_path, target_size, temp_dir, i), duration=3.0)
-                    page_clips.append(img_clip)
+                    page_clips.append(ImageClip(self._prepare_img(img_path, target_size, temp_dir, i), duration=3.0))
 
             final_path = os.path.join(temp_dir, "output.mp4")
             final_clip = concatenate_videoclips(page_clips, method="compose")
-            final_clip.write_videofile(final_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
+            print("[SlidesVideo] Rendering final transformed video in background thread...")
+            await asyncio.to_thread(final_clip.write_videofile, final_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
             
-            # Cleanup clips
             for c in page_clips: c.close()
             final_clip.close()
 
-            # Upload to S3
-            ts = int(time.time())
-            s3_key = f"users/video_summaries/{ts}_summary.mp4"
-            s3_service.s3_client.upload_file(final_path, settings.AWS_S3_BUCKET, s3_key)
-            s3_url = f"https://{settings.AWS_S3_BUCKET}.s3.{settings.AWS_REGION}.amazonaws.com/{s3_key}"
-
-            return {"s3_key": s3_key, "s3_url": s3_url}
-
+            ts = int(time.time()); s3_key = f"users/video_summaries/{ts}_summary.mp4"
+            print(f"[SlidesVideo] Uploading final transformed video to S3: {s3_key}")
+            await asyncio.to_thread(s3_service.s3_client.upload_file, final_path, settings.AWS_S3_BUCKET, s3_key)
+            return {"s3_key": s3_key, "s3_url": f"https://{settings.AWS_S3_BUCKET}.s3.{settings.AWS_REGION}.amazonaws.com/{s3_key}"}
         finally:
             shutil.rmtree(temp_dir, ignore_errors=True)
 
     def _prepare_img(self, path, size, temp_dir, idx):
-        img = Image.open(path)
-        img.thumbnail(size, Image.Resampling.LANCZOS)
-        new_img = Image.new("RGB", size, (0, 0, 0))
-        new_img.paste(img, ((size[0] - img.size[0]) // 2, (size[1] - img.size[1]) // 2))
-        res_path = os.path.join(temp_dir, f"ready_{idx}.png")
-        new_img.save(res_path)
-        return res_path
-
-    async def generate_transformed_video_summary(
-        self,
-        file_key: str,
-        language: str = "Japanese",
-        voice_name: str = "Kore",
-        custom_prompt: str = ""
-    ) -> Dict[str, Any]:
-        """
-        The Full Transformation Workflow: PDF -> Text -> Outline -> Slides -> PDF -> Video.
-        """
+        img = Image.open(path); img.thumbnail(size, Image.Resampling.LANCZOS)
+        new_img = Image.new("RGB", size, (0, 0, 0)); new_img.paste(img, ((size[0] - img.size[0]) // 2, (size[1] - img.size[1]) // 2))
+        res_path = os.path.join(temp_dir, f"ready_{idx}.png"); new_img.save(res_path); return res_path
+
+    async def generate_transformed_video_summary(self, file_key: str, language: str = "Japanese", voice_name: str = "Kore", custom_prompt: str = "") -> Dict[str, Any]:
         temp_dir = tempfile.mkdtemp(prefix="trans_video_")
         try:
-            # 1. Download original PDF
             pdf_path = os.path.join(temp_dir, "input.pdf")
-            s3_service.s3_client.download_file(settings.AWS_S3_BUCKET, file_key, pdf_path)
-
-            # 2. Extract Text
-            logger.info("Extracting text from PDF...")
+            print(f"[SlidesVideo] Downloading source PDF: {file_key}")
+            await asyncio.to_thread(s3_service.s3_client.download_file, settings.AWS_S3_BUCKET, file_key, pdf_path)
             source_text = await self.extract_text_from_pdf(pdf_path)
-
-            # 3. Generate Outline
-            logger.info("Generating slide outline...")
             outline = await self.generate_outline(source_text, language, custom_prompt)
-
-            # 4. Create Slides and Export back to PDF (The Transformation)
-            logger.info("Building Google Slides and exporting...")
             transformed_pdf_bytes = await self.create_slides_and_export_pdf(outline)
-
-            # 5. Generate Video from the Transformed PDF
-            logger.info("Generating video from transformed slides...")
             result = await self.generate_video_from_pdf_bytes(transformed_pdf_bytes, language, voice_name)
-            
-            return {
-                "title": f"Transformed Summary - {os.path.basename(file_key)}",
-                "s3_key": result["s3_key"],
-                "s3_url": result["s3_url"]
-            }
-
+            return {"title": f"Transformed Summary - {os.path.basename(file_key)}", "s3_key": result["s3_key"], "s3_url": result["s3_url"]}
         finally:
             shutil.rmtree(temp_dir, ignore_errors=True)
 

services/video_generator_service.py

@@ -1,5 +1,5 @@
 import json
-import logging
+import asyncio
 import os
 import tempfile
 import time
@@ -7,8 +7,7 @@ import shutil
 from typing import List, Dict, Optional, Any
 import wave
 
-import openai
-from google import genai
+from openai import AsyncOpenAI
 from google.genai import types
 from PIL import Image
 from pdf2image import convert_from_path
@@ -17,15 +16,14 @@ from moviepy import ImageClip, AudioFileClip, VideoFileClip, concatenate_videocl
 from core.config import settings
 from core.prompts import get_video_script_prompt
 from services.s3_service import s3_service
-
-logger = logging.getLogger(__name__)
+from google import genai
 
 class VideoGeneratorService:
     def __init__(self):
-        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+        self.openai_client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
         
         # Match Temp project: Use API Key for Gemini TTS
-        logger.info("Initializing Gemini Client with API Key (as in Temp project)")
+        print("[VideoGenerator] Initializing Gemini Client with API Key")
         self.gemini_client = genai.Client(api_key=settings.GEMINI_API_KEY)
 
     async def generate_video_summary(
@@ -40,19 +38,20 @@ class VideoGeneratorService:
         temp_dir = tempfile.mkdtemp(prefix="video_gen_")
         try:
             # 1. Download PDF from S3
+            print(f"[VideoGenerator] Starting generation for: {file_key}")
             pdf_path = os.path.join(temp_dir, "input.pdf")
-            s3_service.s3_client.download_file(settings.AWS_S3_BUCKET, file_key, pdf_path)
+            await asyncio.to_thread(s3_service.s3_client.download_file, settings.AWS_S3_BUCKET, file_key, pdf_path)
 
-            # 2. Convert PDF to Images to get page count and for later use
+            # 2. Convert PDF to Images
             image_dir = os.path.join(temp_dir, "images")
             os.makedirs(image_dir, exist_ok=True)
             
-            # Poppler check (Windows usually needs path)
             poppler_path = os.environ.get("POPPLER_PATH")
+            print("[VideoGenerator] Converting PDF to images...")
             if poppler_path:
-                images = convert_from_path(pdf_path, dpi=200, poppler_path=poppler_path)
+                images = await asyncio.to_thread(convert_from_path, pdf_path, dpi=200, poppler_path=poppler_path)
             else:
-                images = convert_from_path(pdf_path, dpi=200)
+                images = await asyncio.to_thread(convert_from_path, pdf_path, dpi=200)
             
             total_pages = len(images)
             image_paths = []
@@ -61,14 +60,18 @@ class VideoGeneratorService:
                 img.save(img_path, "PNG")
                 image_paths.append(img_path)
 
-            # 3. Generate Narration Script (OpenAI)
+            # 3. Generate Narration Script (Native Async OpenAI)
+            print(f"[VideoGenerator] Generating script with OpenAI for {total_pages} pages...")
             with open(pdf_path, "rb") as f:
-                openai_file = self.openai_client.files.create(file=f, purpose="assistants")
+                content = f.read()
+                
+            openai_file = await self.openai_client.files.create(
+                file=("source.pdf", content), 
+                purpose="assistants"
+            )
             
-            # Using the new high-fidelity prompt
             prompt = get_video_script_prompt(language, total_pages)
-            
-            response = self.openai_client.chat.completions.create(
+            response = await self.openai_client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[
                     {
@@ -85,21 +88,16 @@ class VideoGeneratorService:
             
             script_data = json.loads(response.choices[0].message.content)
             scripts = script_data.get("scripts", [])
-            
-            # Cleanup OpenAI file
-            self.openai_client.files.delete(openai_file.id)
+            await self.openai_client.files.delete(openai_file.id)
 
-            # 4. Generate Audio for each page (Gemini TTS)
+            # 4. Generate Audio (Native Async Gemini)
             audio_dir = os.path.join(temp_dir, "audio")
             os.makedirs(audio_dir, exist_ok=True)
             audio_paths = []
 
-            # We iterate through scripts. Usually total_pages.
-            # Mirror original repo: last page (logo) is often skipped for audio.
             for i, script in enumerate(scripts):
-                # If it's the last page, skip audio (standard behavior in the template project)
                 if i == len(scripts) - 1:
-                    logger.info(f"Skipping audio for last page (logo slide)")
+                    print("[VideoGenerator] Skipping audio for last page (logo slide)")
                     continue
 
                 page_num = script.get("page_number", i+1)
@@ -107,14 +105,12 @@ class VideoGeneratorService:
                 if not text: continue
 
                 audio_path = os.path.join(audio_dir, f"audio_{page_num:02d}.wav")
+                print(f"[VideoGenerator] Generating TTS for page {page_num}...")
                 
-                # Gemini TTS with fallback
                 try:
-                    # Default model from original repo
+                    # Use Native Async Gemini
                     model_name = "gemini-2.5-flash-preview-tts"
-                    logger.info(f"Generating audio for page {page_num} using {model_name}...")
-                    
-                    tts_resp = self.gemini_client.models.generate_content(
+                    tts_resp = await self.gemini_client.aio.models.generate_content(
                         model=model_name,
                         contents=text,
                         config=types.GenerateContentConfig(
@@ -129,11 +125,9 @@ class VideoGeneratorService:
                         )
                     )
                 except Exception as tts_err:
-                    logger.warning(f"Failed with {model_name}, trying fallback gemini-1.5-flash: {tts_err}")
-                    # Fallback to a highly stable multimodal model
-                    model_name = "gemini-1.5-flash"
-                    tts_resp = self.gemini_client.models.generate_content(
-                        model=model_name,
+                    print(f"[VideoGenerator] TTS Primary failed, using fallback: {tts_err}")
+                    tts_resp = await self.gemini_client.aio.models.generate_content(
+                        model="gemini-1.5-flash",
                         contents=text,
                         config=types.GenerateContentConfig(
                             response_modalities=["AUDIO"],
@@ -149,58 +143,52 @@ class VideoGeneratorService:
                 
                 audio_bytes = tts_resp.candidates[0].content.parts[0].inline_data.data
                 with wave.open(audio_path, "wb") as wf:
-                    wf.setnchannels(1)
-                    wf.setsampwidth(2)
-                    wf.setframerate(24000)
-                    wf.writeframes(audio_bytes)
+                    wf.setnchannels(1); wf.setsampwidth(2); wf.setframerate(24000); wf.writeframes(audio_bytes)
                 
                 audio_paths.append(audio_path)
-                # Rate limiting guard: wait between audio gens
-                time.sleep(3)
+                await asyncio.sleep(2) # Non-blocking sleep
 
-            # 5. Combine into individual videos and then final video (MoviePy)
+            # 5. Assembly (MoviePy in Thread)
+            print("[VideoGenerator] Assembled audio/images. Now rendering final video with MoviePy (background thread)...")
             page_clips = []
             target_size = (1920, 1080)
 
             for i, img_path in enumerate(image_paths):
-                # Match audio if available (some pages might not have script if script gen failed or skipped)
-                # Usually we want 1 image per audio.
+                img = Image.open(img_path)
+                img = self._resize_and_pad(img, target_size)
+                temp_img_res = os.path.join(temp_dir, f"res_{i}.png")
+                img.save(temp_img_res)
+
                 if i < len(audio_paths):
                     aud_clip = AudioFileClip(audio_paths[i])
-                    duration = aud_clip.duration
-                    
-                    # Process image to fit 1080p
-                    img = Image.open(img_path)
-                    img = self._resize_and_pad(img, target_size)
-                    temp_img_res = os.path.join(temp_dir, f"res_{i}.png")
-                    img.save(temp_img_res)
-                    
-                    img_clip = ImageClip(temp_img_res, duration=duration)
-                    vid_clip = img_clip.with_audio(aud_clip)
-                    page_clips.append(vid_clip)
+                    img_clip = ImageClip(temp_img_res, duration=aud_clip.duration)
+                    page_clips.append(img_clip.with_audio(aud_clip))
                 else:
-                    # Final page or extra pages - silent 3s
-                    img = Image.open(img_path)
-                    img = self._resize_and_pad(img, target_size)
-                    temp_img_res = os.path.join(temp_dir, f"res_{i}.png")
-                    img.save(temp_img_res)
-                    img_clip = ImageClip(temp_img_res, duration=3.0)
-                    page_clips.append(img_clip)
+                    page_clips.append(ImageClip(temp_img_res, duration=3.0))
 
             final_video_path = os.path.join(temp_dir, "final.mp4")
             final_clip = concatenate_videoclips(page_clips, method="compose")
-            final_clip.write_videofile(final_video_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
+            
+            await asyncio.to_thread(
+                final_clip.write_videofile, 
+                final_video_path, 
+                fps=24, 
+                codec="libx264", 
+                audio_codec="aac", 
+                logger=None
+            )
 
-            # Cleanup clips
             for clip in page_clips: clip.close()
-            if final_clip: final_clip.close()
+            final_clip.close()
 
             # 6. Upload to S3
             timestamp = int(time.time())
             s3_key = f"users/video_summaries/{timestamp}_summary.mp4"
-            s3_service.s3_client.upload_file(final_video_path, settings.AWS_S3_BUCKET, s3_key)
+            print(f"[VideoGenerator] Uploading final video to S3: {s3_key}")
+            await asyncio.to_thread(s3_service.s3_client.upload_file, final_video_path, settings.AWS_S3_BUCKET, s3_key)
             s3_url = f"https://{settings.AWS_S3_BUCKET}.s3.{settings.AWS_REGION}.amazonaws.com/{s3_key}"
 
+            print(f"[VideoGenerator] Success! Video ready at: {s3_url}")
             return {
                 "title": f"Video Summary - {os.path.basename(file_key)}",
                 "s3_key": s3_key,
@@ -208,7 +196,7 @@ class VideoGeneratorService:
             }
 
         except Exception as e:
-            logger.error(f"Video generation failed: {e}")
+            print(f"[VideoGenerator] ERROR: {str(e)}")
             import traceback
             traceback.print_exc()
             raise