v1

Dockerfile

@@ -0,0 +1,28 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set work directory
+WORKDIR /app
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Hugging Face Spaces expects the app to run on port 7860
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,16 @@
 ---
-title: AIdea Server
-emoji: 😻
-colorFrom: yellow
+title: AIdea Note Generator
+emoji: 📝
+colorFrom: blue
 colorTo: purple
 sdk: docker
+app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: AIdea is app that simplifies watching videos by beautiful we
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# YouTube Study Notes AI
+
+![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+An intelligent AI system that automatically generates structured study notes from YouTube educational videos using speech recognition and large language models.

app.py

@@ -0,0 +1,5 @@
+import uvicorn
+from src.api.main import app
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,28 @@
+yt-dlp==2024.12.23
+pydub==0.25.1
+openai-whisper==20250625
+torch
+torchaudio
+google-genai
+google-generativeai==0.3.2
+langchain==0.1.0
+langchain-google-genai==0.0.5
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+pydantic==2.12.5
+pydantic[email]
+email-validator
+pydantic-settings==2.1.0
+python-multipart==0.0.6
+python-dotenv==1.0.0
+httpx==0.26.0
+aiofiles==23.2.1
+sqlmodel==0.0.14
+asyncpg==0.31.0
+greenlet==3.3.1
+passlib[bcrypt]==1.7.4
+python-jose[cryptography]==3.3.0
+bcrypt==4.1.2
+google-api-python-client==2.115.0
+pydantic-core==2.41.5
+ffmpeg-python

src/api/main.py

@@ -0,0 +1,156 @@
+import uuid
+from datetime import datetime
+from typing import Dict
+from enum import Enum
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, HttpUrl
+
+from src.ai_modules.transcription.audio_downloader import YouTubeDownloader
+from src.ai_modules.transcription.whisper_transcriber import WhisperTranscriber
+from src.ai_modules.summarization.note_generator import NoteGenerator
+from src.utils.logger import setup_logger
+from src.db.database import create_db_and_tables, async_engine
+from src.db.models import Note, User
+from src.auth.dependencies import get_current_user
+from src.api.auth_routes import router as auth_router
+from src.api.notes_routes import router as notes_router
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+logger = setup_logger(__name__)
+
+
+# --- Models ---
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    DOWNLOADING = "downloading"
+    TRANSCRIBING = "transcribing"
+    GENERATING_NOTES = "generating_notes"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class GenerateNotesRequest(BaseModel):
+    youtube_url: HttpUrl
+    language: str = "en"
+
+
+class TaskResponse(BaseModel):
+    task_id: str
+    status: TaskStatus
+    message: str
+
+
+# Global task storage
+tasks: Dict[str, Dict] = {}
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("Lifespan: Initializing database tables...")
+    await create_db_and_tables()
+    yield
+
+
+app = FastAPI(title="YouTube Study Notes AI", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Routes ---
+app.include_router(auth_router)
+app.include_router(notes_router)
+
+
+@app.post("/generate", response_model=TaskResponse)
+async def generate(
+    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": TaskStatus.PENDING,
+        "message": "Initializing...",
+        "youtube_url": str(request.youtube_url),
+        "user_id": user_id,
+        "created_at": datetime.now(),
+    }
+
+    background_tasks.add_task(
+        process_video_and_save,
+        task_id,
+        str(request.youtube_url),
+        request.language,
+        user_id,
+    )
+
+    return TaskResponse(
+        task_id=task_id,
+        status=TaskStatus.PENDING,
+        message="Generation started successfully.",
+    )
+
+
+async def process_video_and_save(
+    task_id: str, youtube_url: str, language: str, user_id: int
+):
+    audio_file = None
+    try:
+        tasks[task_id]["status"] = TaskStatus.DOWNLOADING
+        downloader = YouTubeDownloader()
+        video_info = downloader.get_video_info(youtube_url)
+        audio_file = downloader.download_audio(youtube_url, task_id)
+
+        tasks[task_id]["status"] = TaskStatus.TRANSCRIBING
+        transcriber = WhisperTranscriber()
+        transcript_data = transcriber.transcribe(audio_file, language=language)
+
+        tasks[task_id]["status"] = TaskStatus.GENERATING_NOTES
+        note_gen = NoteGenerator()
+        json_notes = note_gen.generate_notes_json(
+            transcript_data["text"], video_info["title"]
+        )
+        final_notes = note_gen.format_final_notes(
+            note_gen.format_notes_to_markdown(json_notes),
+            video_info["title"],
+            youtube_url,
+            video_info["duration"],
+        )
+
+        async with AsyncSession(async_engine) as session:
+            new_note = Note(
+                user_id=user_id,
+                video_url=youtube_url,
+                video_title=video_info["title"],
+                summary_content=final_notes,
+            )
+            session.add(new_note)
+            await session.commit()
+            await session.refresh(new_note)
+
+        tasks[task_id]["notes"] = final_notes
+        tasks[task_id]["keyPoints"] = json_notes.get("key_points", []) if isinstance(json_notes, dict) else []
+        tasks[task_id]["status"] = TaskStatus.COMPLETED
+    except Exception as e:
+        logger.error(f"Task failed: {e}")
+        tasks[task_id]["status"] = TaskStatus.FAILED
+    finally:
+        if audio_file and audio_file.exists():
+            downloader.cleanup(audio_file)
+
+
+@app.get("/status/{task_id}")
+async def get_task_status(task_id: str):
+    if task_id not in tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return tasks[task_id]