Update src/api/notes_routes.py

src/api/notes_routes.py

@@ -1,232 +1,193 @@
-"""
-Notes management API endpoints.
-"""
-
-from sqlmodel.ext.asyncio.session import AsyncSession
-from typing import List, Optional
-from pathlib import Path
+import uuid
+import re
+import logging
 import os
+from datetime import datetime
+from typing import List, Optional, Dict
+from pathlib import Path
 
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from fastapi.responses import FileResponse, JSONResponse
+from fastapi import APIRouter, Depends, HTTPException, status, Query, BackgroundTasks
 from pydantic import BaseModel, HttpUrl, Field
-from sqlmodel import Session, select
 
 from src.db.firebase import get_firebase_db
 from src.db.models import User, Note
 from src.auth.dependencies import get_current_user
-from src.categorization.categorizer import CategorizationService
 from src.utils.logger import setup_logger
 from src.utils.config import settings
 
-logger = setup_logger(__name__)
-categorizer = CategorizationService()
+# --- استدعاء أدوات المعالجة الجديدة ---
+from src.api.downloader import YouTubeDownloader
+from src.transcription.transcript_fetcher import TranscriptFetcher
+from src.transcription.whisper_transcriber import WhisperTranscriber
+from src.summarization.note_generator import NoteGenerator
 
+logger = setup_logger(__name__)
 router = APIRouter(prefix="/notes", tags=["Notes"])
 
+# مخزن المهام المؤقت في الذاكرة
+tasks: Dict[str, Dict] = {}
+
+# --- Models ---
+class GenerateNotesRequest(BaseModel):
+    youtube_url: HttpUrl
+    language: str = "en"
+
+class TaskResponse(BaseModel):
+    task_id: str
+    status: str
+    message: str
 
-# --- New Models for File-based Notes ---
 class GeneratedNoteFile(BaseModel):
     filename: str
     title: str
     created_at: float
     size: int
 
+# ==========================================
+# 🚀 محرك توليد الملاحظات (Generate Engine)
+# ==========================================
 
-# --- Existing Models ---
-class CreateNoteRequest(BaseModel):
-    video_url: HttpUrl = Field(..., description="YouTube video URL")
-    video_title: str = Field(..., max_length=500, description="Video title")
-    summary_text: str = Field(..., description="Generated study notes in markdown")
-    video_duration: Optional[int] = Field(None, description="Video duration in seconds")
-    language: str = Field(
-        default="en", max_length=10, description="Video language code"
-    )
+@router.post("/generate", response_model=TaskResponse)
+async def generate_note(
+    request: GenerateNotesRequest,
+    background_tasks: BackgroundTasks,
+    current_user: User = Depends(get_current_user),
+):
+    """البدء في توليد ملاحظات من فيديو يوتيوب"""
+    task_id = str(uuid.uuid4())
+    user_id = current_user.id
+
+    tasks[task_id] = {
+        "status": "pending",
+        "message": "Initializing process...",
+        "youtube_url": str(request.youtube_url),
+        "user_id": user_id,
+        "created_at": datetime.now(),
+    }
 
+    # تشغيل المهمة في الخلفية
+    background_tasks.add_task(
+        process_video_task,
+        task_id,
+        str(request.youtube_url),
+        request.language,
+        user_id
+    )
 
-class NoteResponse(BaseModel):
-    id: str  # Changed to str for Firestore IDs
-    video_url: str
-    video_title: str
-    summary_text: str
-    video_duration: Optional[int]
-    language: str
-    user_id: str  # Changed to str
-    category: Optional[str]
-    created_at: str
+    return TaskResponse(
+        task_id=task_id,
+        status="pending",
+        message="Generation started successfully."
+    )
 
+@router.get("/status/{task_id}")
+async def get_task_status(task_id: str):
+    """متابعة حالة المهمة (pending, downloading, transcribing, etc.)"""
+    if task_id not in tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return tasks[task_id]
 
 # ==========================================
-# ✅ NEW ENDPOINTS: Read from 'outputs' folder
+# 🛠️ دالات المعالجة (Background Logic)
 # ==========================================
 
+async def process_video_task(task_id: str, youtube_url: str, language: str, user_id: str):
+    audio_file = None
+    downloader = YouTubeDownloader()
+    
+    try:
+        # استخراج الـ Video ID
+        video_id_match = re.search(r"(?:v=|youtu\.be/)([A-Za-z0-9_-]{11})", youtube_url)
+        video_id = video_id_match.group(1) if video_id_match else task_id
+        video_title = "YouTube Video"
+
+        # 1. محاولة جلب النص (Transcript)
+        tasks[task_id]["status"] = "fetching_transcript"
+        fetcher = TranscriptFetcher()
+        try:
+            transcript_text = fetcher.fetch_transcript(youtube_url, languages=[language, 'ar', 'en'])
+        except:
+            transcript_text = None
+
+        # 2. لو مفيش ترجمة، نحمل الصوت ونستخدم Whisper
+        if not transcript_text:
+            tasks[task_id]["status"] = "downloading"
+            logger.info(f"Downloading audio with POT Solver for: {video_id}")
+            audio_file = downloader.download_audio(youtube_url, video_id)
+            
+            if not audio_file:
+                raise Exception("Failed to download audio after multiple attempts.")
+
+            tasks[task_id]["status"] = "transcribing"
+            transcriber = WhisperTranscriber()
+            transcript_data = transcriber.transcribe(str(audio_file), language=language)
+            transcript_text = transcript_data["text"]
+
+        # 3. توليد الملاحظات بالـ AI
+        tasks[task_id]["status"] = "generating_notes"
+        note_gen = NoteGenerator()
+        summary_json = note_gen.generateSummary(transcript_text, video_title)
+        action_items = note_gen.extractActionItems(transcript_text, video_title)
+
+        combined_notes = {
+            **summary_json,
+            "action_items": action_items.get("action_items", [])
+        }
+
+        final_markdown = note_gen.format_final_notes(
+            note_gen.format_notes_to_markdown(combined_notes),
+            video_title,
+            youtube_url,
+            0, # duration placeholder
+        )
+
+        # 4. الحفظ في Firebase
+        db = get_firebase_db()
+        if db:
+            db.collection("notes").add({
+                "user_id": user_id,
+                "video_url": youtube_url,
+                "video_title": video_title,
+                "summary_content": final_markdown,
+                "created_at": datetime.utcnow()
+            })
+
+        tasks[task_id]["status"] = "completed"
+        tasks[task_id]["notes"] = final_markdown
+        logger.info(f"✅ Task {task_id} finished!")
+
+    except Exception as e:
+        logger.error(f"❌ Task {task_id} failed: {e}")
+        tasks[task_id]["status"] = "failed"
+        tasks[task_id]["message"] = str(e)
+    finally:
+        if audio_file and downloader:
+            downloader.cleanup(audio_file)
+
+# ==========================================
+# 📂 إدارة الملفات (File Management)
+# ==========================================
 
 @router.get("/generated", response_model=List[GeneratedNoteFile])
 async def list_generated_notes():
-    """
-    List all markdown files found in the 'outputs' directory.
-    This bypasses the database to show files directly.
-    """
     notes = []
     output_dir = settings.output_dir
+    if not output_dir.exists(): return []
 
-    # Create directory if it doesn't exist
-    if not output_dir.exists():
-        return []
-
-    # Scan for .md files
-    # We look for files ending with _notes.md
     for file_path in output_dir.glob("*_notes.md"):
-        try:
-            # Try to read the first line to get a clean title
-            content = file_path.read_text(encoding="utf-8")
-            lines = content.split("\n")
-            # Usually the first line is "# Title"
-            title = lines[0].replace("#", "").strip() if lines else file_path.name
-
-            stats = file_path.stat()
-
-            notes.append(
-                GeneratedNoteFile(
-                    filename=file_path.name,
-                    title=title if title else file_path.name,
-                    created_at=stats.st_mtime,
-                    size=stats.st_size,
-                )
-            )
-        except Exception as e:
-            logger.error(f"Error reading file {file_path}: {e}")
-            continue
-
-    # Sort by newest first
+        stats = file_path.stat()
+        notes.append(GeneratedNoteFile(
+            filename=file_path.name,
+            title=file_path.name.replace("_notes.md", ""),
+            created_at=stats.st_mtime,
+            size=stats.st_size,
+        ))
     notes.sort(key=lambda x: x.created_at, reverse=True)
     return notes
 
-
 @router.get("/generated/{filename}")
-async def get_generated_note_content(filename: str):
-    """
-    Get the full content of a specific markdown file.
-    """
-    # Security check: prevent directory traversal
-    if ".." in filename or "/" in filename:
-        raise HTTPException(status_code=400, detail="Invalid filename")
-
+async def get_note_content(filename: str):
     file_path = settings.output_dir / filename
-
     if not file_path.exists():
-        raise HTTPException(status_code=404, detail="Note file not found")
-
-    content = file_path.read_text(encoding="utf-8")
-    return {"content": content, "filename": filename}
-
-
-# ==========================================
-# End of New Endpoints
-# ==========================================
-
-
-@router.get("/{note_id}", response_model=NoteResponse)
-async def get_note(
-    note_id: str,
-    current_user: User = Depends(get_current_user),
-):
-    """
-    Get a specific note by ID from Firestore.
-    """
-    db = get_firebase_db()
-    if db is None:
-        raise HTTPException(status_code=500, detail="Firebase not configured")
-
-    note_ref = db.collection("notes").document(note_id)
-    note_doc = note_ref.get()
-
-    if not note_doc.exists:
-        raise HTTPException(status_code=404, detail="Note not found")
-
-    note_data = note_doc.to_dict()
-    if note_data.get("user_id") != current_user.id:
-        raise HTTPException(status_code=403, detail="Forbidden")
-
-    return NoteResponse(
-        id=note_doc.id,
-        video_url=note_data["video_url"],
-        video_title=note_data["video_title"],
-        summary_text=note_data["summary_content"],
-        video_duration=None,
-        language="en",
-        user_id=note_data["user_id"],
-        category=note_data.get("category"),
-        created_at=str(note_data.get("created_at")),
-    )
-
-
-@router.get("", response_model=List[NoteResponse])
-async def list_user_notes(
-    current_user: User = Depends(get_current_user),
-):
-    """
-    List all notes belonging to the current user from Firestore.
-    """
-    db = get_firebase_db()
-    if db is None:
-        return []
-
-    notes_ref = db.collection("notes")
-    query = (
-        notes_ref.where("user_id", "==", current_user.id)
-        .order_by("created_at", direction="DESCENDING")
-        .stream()
-    )
-
-    return [
-        NoteResponse(
-            id=doc.id,
-            video_url=data["video_url"],
-            video_title=data["video_title"],
-            summary_text=data["summary_content"],
-            video_duration=None,
-            language="en",
-            user_id=data["user_id"],
-            category=data.get("category"),
-            created_at=str(data.get("created_at")),
-        )
-        for doc in query
-        if (data := doc.to_dict())
-    ]
-
-
-@router.post("", response_model=NoteResponse, status_code=status.HTTP_201_CREATED)
-async def create_note(
-    note_data: CreateNoteRequest,
-    current_user: User = Depends(get_current_user),
-):
-    # Automatically categorize the note
-    category = await categorizer.categorize_text(note_data.summary_text)
-
-    db = get_firebase_db()
-    if db is None:
-        raise HTTPException(status_code=500, detail="Firebase not configured")
-
-    note_dict = {
-        "video_url": str(note_data.video_url),
-        "video_title": note_data.video_title,
-        "summary_content": note_data.summary_text,
-        "user_id": current_user.id,
-        "category": category,
-        "created_at": datetime.utcnow()
-    }
-
-    _, new_note_ref = db.collection("notes").add(note_dict)
-
-    return NoteResponse(
-        id=new_note_ref.id,
-        video_url=note_dict["video_url"],
-        video_title=note_dict["video_title"],
-        summary_text=note_dict["summary_content"],
-        video_duration=None,
-        language="en",
-        user_id=note_dict["user_id"],
-        category=note_dict["category"],
-        created_at=str(note_dict["created_at"]),
-    )
+        raise HTTPException(status_code=404, detail="File not found")
+    return {"content": file_path.read_text(encoding="utf-8")}