Upload folder using huggingface_hub

api/canvas.py

@@ -0,0 +1,147 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Response
+from sqlalchemy.orm import Session
+from typing import List, Optional
+import logging
+from datetime import datetime
+
+from core.database import get_db
+from models import db_models
+from models.schemas import CanvasCreateRequest, CanvasEditRequest, CanvasResponse
+from services.canvas_service import canvas_service
+from api.auth import get_current_user
+
+router = APIRouter(prefix="/api/canvas", tags=["Canvas - Collaborative Editing"])
+logger = logging.getLogger(__name__)
+
+@router.post("/create", response_model=CanvasResponse)
+async def create_canvas(
+    request: CanvasCreateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Create a new Canvas entry. 
+    Pass file_key to extract text and generate an initial Markdown summary.
+    """
+    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=404, detail="Source file not found")
+            source_id = source.id
+        
+        # Create initial record
+        title = request.title or f"Canvas {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        db_canvas = db_models.Canvas(
+            title=title,
+            user_id=current_user.id,
+            source_id=source_id,
+            status="processing"
+        )
+        db.add(db_canvas)
+        db.commit()
+        db.refresh(db_canvas)
+
+        try:
+            # Generate summary
+            content = await canvas_service.generate_canvas_summary(
+                file_key=request.file_key,
+                text_input=request.text_input
+            )
+            
+            db_canvas.text = content
+            db_canvas.status = "completed"
+            db.commit()
+            db.refresh(db_canvas)
+            
+            return db_canvas
+
+        except Exception as e:
+            db_canvas.status = "failed"
+            db_canvas.error_message = str(e)
+            db.commit()
+            raise HTTPException(status_code=500, detail=f"Generation failed: {str(e)}")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating canvas: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/", response_model=List[CanvasResponse])
+async def list_canvases(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """List all canvases for the current user."""
+    return db.query(db_models.Canvas).filter(db_models.Canvas.user_id == current_user.id).all()
+
+@router.get("/{canvas_id}", response_model=CanvasResponse)
+async def get_canvas(
+    canvas_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Get a specific canvas by ID."""
+    canvas = db.query(db_models.Canvas).filter(
+        db_models.Canvas.id == canvas_id,
+        db_models.Canvas.user_id == current_user.id
+    ).first()
+    if not canvas:
+        raise HTTPException(status_code=404, detail="Canvas not found")
+    return canvas
+
+@router.post("/{canvas_id}/update", response_model=CanvasResponse)
+async def update_canvas_text(
+    canvas_id: int,
+    request: CanvasEditRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Manually update the text of an existing canvas.
+    """
+    db_canvas = db.query(db_models.Canvas).filter(
+        db_models.Canvas.id == canvas_id,
+        db_models.Canvas.user_id == current_user.id
+    ).first()
+    
+    if not db_canvas:
+        raise HTTPException(status_code=404, detail="Canvas not found")
+
+    try:
+        db_canvas.text = request.text
+        db_canvas.status = "completed"
+        db.commit()
+        db.refresh(db_canvas)
+        
+        return db_canvas
+
+    except Exception as e:
+        logger.error(f"Error updating canvas: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{canvas_id}")
+async def delete_canvas(
+    canvas_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Delete a canvas."""
+    db_canvas = db.query(db_models.Canvas).filter(
+        db_models.Canvas.id == canvas_id,
+        db_models.Canvas.user_id == current_user.id
+    ).first()
+    
+    if not db_canvas:
+        raise HTTPException(status_code=404, detail="Canvas not found")
+        
+    db.delete(db_canvas)
+    db.commit()
+    return {"message": "Canvas deleted successfully"}
+

core/database.py

@@ -11,7 +11,7 @@ SQLALCHEMY_DATABASE_URL = settings.DATABASE_URL or "sqlite:///./temp.db"
 engine = create_engine(
     SQLALCHEMY_DATABASE_URL,
     pool_pre_ping=True,    # Check connection health before every query
-    pool_recycle=120,      # Refresh connections every 2 minutes (more aggressive)
+    pool_recycle=1800,  # 30 minutes (best practice)
     pool_timeout=30,       # Wait up to 30 seconds for a connection
     pool_size=15,          # Maintain a slightly larger pool
     max_overflow=25,       # Allow more overflow if busy

core/prompts.py

@@ -327,7 +327,12 @@ def get_quiz_system_prompt(language: str = "Japanese") -> str:
     {
       "question": "問題文",
       "hint": "ヒント",
-      "choices": { "1": "選択肢1", "2": "選択肢2", "3": "選択肢3", "4": "選択肢4" },
+      "choices": [
+        { "value": "1", "label": "選択肢1" },
+        { "value": "2", "label": "選択肢2" },
+        { "value": "3", "label": "選択肢3" },
+        { "value": "4", "label": "選択肢4" }
+      ],
       "answer": "1|2|3|4 のいずれか",
       "explanation": "正解の詳細な説明"
     }
@@ -357,7 +362,12 @@ Output format (and nothing else):
     {
       "question": "Question",
       "hint": "Hint",
-      "choices": { "1": "Choice 1", "2": "Choice 2", "3": "Choice 3", "4": "Choice 4" },
+      "choices": [
+        { "value": "1", "label": "Choice 1" },
+        { "value": "2", "label": "Choice 2" },
+        { "value": "3", "label": "Choice 3" },
+        { "value": "4", "label": "Choice 4" }
+      ],
       "answer": "1|2|3|4",
       "explanation": "Detailed reasoning for why this is correct"
     }
@@ -574,3 +584,28 @@ def get_outline_prompt(template_yaml_text: str, source_text: str, custom_prompt:
             + ("## 追加指示\n\n" + extra + "\n\n" if extra else "")
             + "## 入力\n\n* TEMPLATE_YAML:\n\n" + template_yaml_text + "\n\n* SOURCE_TEXT:\n\n" + source_text
         )
+
+def get_canvas_system_prompt() -> str:
+    return """You are a professional content editor and writing assistant. Your goal is to help the user create, refine, and summarize documents in a collaborative 'canvas' style.
+
+    INSTRUCTIONS:
+    1. When creating a summary, focus on clarity, accuracy, and structure.
+    2. Use Markdown formatting for headings, bullet points, and emphasis.
+    3. Ensure the content is easy to read and logically organized.
+    4. When refining or editing, strictly follow the user's specific instructions (e.g., tone change, expansion, shortening).
+    5. Output should be ONLY the Markdown content. Do not include any other text or explanation.
+    6. CRITICAL: Do NOT escape any characters like quotes or newlines. Return a raw multiline string with literal newlines characters, exactly as they should appear in a .md file. Do not wrap the output in a JSON object or string."""
+
+def get_canvas_edit_prompt(instruction: str, current_content: str) -> str:
+  return f"""The user wants you to edit the following document based on this instruction: "{instruction}"
+
+    CURRENT CONTENT:
+    ---
+    {current_content}
+    ---
+
+    Your task:
+    - Apply the user's instruction to the document.
+    - Preserve the overall meaning unless asked to change it.
+    - Maintain the Markdown structure.
+    - Return ONLY the updated Markdown content. Do not include any other text or explanation."""

main.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from core.database import init_db
-from api import auth, sources, podcast, flashcards, mindmaps, quizzes, reports, video_generator, rag, chat, websocket_routes
+from api import auth, sources, podcast, flashcards, mindmaps, quizzes, reports, video_generator, rag, chat, websocket_routes, canvas
 
 # Initialize Database Tables
 init_db()
@@ -32,6 +32,7 @@ app.include_router(reports.router)
 app.include_router(video_generator.router)
 app.include_router(rag.router)
 app.include_router(chat.router)
+app.include_router(canvas.router)
 app.include_router(websocket_routes.router)  # WebSocket endpoints for real-time progress
 
 @app.get("/")

models/db_models.py

@@ -21,6 +21,7 @@ class User(Base):
     reports = relationship("Report", back_populates="owner")
     video_summaries = relationship("VideoSummary", back_populates="owner")
     rag_documents = relationship("RAGDocument", back_populates="owner")
+    canvases = relationship("Canvas", back_populates="owner")
     chat_messages = relationship("ChatMessage", back_populates="owner", cascade="all, delete-orphan")
 
 class Source(Base):
@@ -42,6 +43,7 @@ class Source(Base):
     reports = relationship("Report", back_populates="source")
     video_summaries = relationship("VideoSummary", back_populates="source")
     rag_documents = relationship("RAGDocument", back_populates="source")
+    canvases = relationship("Canvas", back_populates="source")
 
 class Podcast(Base):
     __tablename__ = "podcasts"
@@ -229,4 +231,24 @@ class ChatMessage(Base):
     content = Column(UnicodeText, nullable=False)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
-    owner = relationship("User", back_populates="chat_messages")
+    owner = relationship("User", back_populates="chat_messages")
+
+class Canvas(Base) :
+    __tablename__ = "canvases"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    text = Column(UnicodeText, nullable=True) # Markdown text
+    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())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+    owner = relationship("User", back_populates="canvases")
+    source = relationship("Source", back_populates="canvases")
+
+    @property
+    def parent_file_key(self):
+        return self.source.s3_key if self.source else None

models/schemas.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, EmailStr
+from pydantic import BaseModel, EmailStr, field_validator
 from typing import List, Optional, Dict, Any
 from datetime import datetime
 
@@ -149,14 +149,26 @@ class QuizGenerateRequest(BaseModel):
     language: str = "English"
     count: str = "STANDARD" # FEWER, STANDARD, MORE
 
+class QuizChoice(BaseModel) :
+    value: str
+    label: str
+
 class QuizQuestionResponse(BaseModel):
     id: int
     question: str
     hint: Optional[str]
-    choices: dict
+    choices: List[QuizChoice]
     answer: str
     explanation: Optional[str]
 
+    @field_validator('choices', mode='before')
+    @classmethod
+    def validate_choices(cls, v):
+        if isinstance(v, dict):
+            # Convert {"1": "label1", "2": "label2"} to [{"value": "1", "label": "label1"}, ...]
+            return [{"value": key, "label": value} for key, value in v.items()]
+        return v
+
     class Config:
         from_attributes = True
 
@@ -276,3 +288,27 @@ class ChatMessageResponse(BaseModel):
 
     class Config:
         from_attributes = True
+
+# Canvas Schemas
+class CanvasCreateRequest(BaseModel):
+    file_key: Optional[str] = None
+    text_input: Optional[str] = None
+    title: Optional[str] = None
+
+class CanvasEditRequest(BaseModel):
+    text: str # The manually edited markdown text
+
+
+class CanvasResponse(BaseModel):
+    id: int
+    title: str
+    text: Optional[str]
+    status: str
+    error_message: Optional[str] = None
+    parent_file_id: Optional[int] = None
+    parent_file_key: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True

services/canvas_service.py

@@ -0,0 +1,139 @@
+import json
+import logging
+import os
+import asyncio
+import tempfile
+import time
+from typing import List, Dict, Optional, Any
+import openai
+
+from core.config import settings
+from core.prompts import get_canvas_system_prompt, get_canvas_edit_prompt
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+class CanvasService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    async def generate_canvas_summary(
+        self,
+        file_key: Optional[str] = None,
+        text_input: Optional[str] = None
+    ) -> str:
+        """
+        Generates a Markdown summary of the provided content.
+        """
+        try:
+            system_prompt = get_canvas_system_prompt()
+            user_msg = "Please analyze the provided content and create a comprehensive, well-structured summary in Markdown format. Output ONLY the raw markdown content without code block markers."
+
+            if file_key:
+                # ... (downloading code unchanged)
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close()
+
+                try:
+                    await asyncio.to_thread(
+                        s3_service.s3_client.download_file,
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    
+                    def upload_to_openai():
+                        with open(tmp_path, "rb") as f:
+                            return self.openai_client.files.create(file=f, purpose="assistants")
+                    
+                    uploaded_file = await asyncio.to_thread(upload_to_openai)
+                    
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {
+                            "role": "user",
+                            "content": [
+                                {"type": "file", "file": {"file_id": uploaded_file.id}},
+                                {"type": "text", "text": user_msg}
+                            ]
+                        }
+                    ]
+                    
+                    response = await asyncio.to_thread(
+                        self.openai_client.chat.completions.create,
+                        model="gpt-4o",
+                        messages=messages,
+                        temperature=0.7
+                    )
+                    
+                    await asyncio.to_thread(self.openai_client.files.delete, uploaded_file.id)
+                    return self._clean_markdown_content(response.choices[0].message.content)
+                    
+                finally:
+                    if os.path.exists(tmp_path):
+                        await asyncio.to_thread(os.remove, tmp_path)
+            
+            elif text_input:
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"{user_msg}\n\nCONTENT:\n{text_input}"}
+                ]
+                
+                response = await asyncio.to_thread(
+                    self.openai_client.chat.completions.create,
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    temperature=0.7
+                )
+                return self._clean_markdown_content(response.choices[0].message.content)
+            
+            else:
+                raise ValueError("Either file_key or text_input must be provided")
+
+        except Exception as e:
+            logger.error(f"Canvas summary generation failed: {e}")
+            raise
+
+    async def refine_canvas(
+        self,
+        instruction: str,
+        current_content: str
+    ) -> str:
+        """
+        Refines existing Markdown content based on user instructions.
+        """
+        try:
+            system_prompt = get_canvas_system_prompt()
+            refine_prompt = get_canvas_edit_prompt(instruction, current_content)
+            
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": refine_prompt}
+            ]
+            
+            response = await asyncio.to_thread(
+                self.openai_client.chat.completions.create,
+                model="gpt-4o",
+                messages=messages,
+                temperature=0.7
+            )
+            
+            return self._clean_markdown_content(response.choices[0].message.content)
+
+        except Exception as e:
+            logger.error(f"Canvas refinement failed: {e}")
+            raise
+
+    def _clean_markdown_content(self, content: str) -> str:
+        """Strips markdown code block markers (```markdown ... ```) if present."""
+        content = content.strip()
+        if content.startswith("```"):
+            # Remove opening marker
+            content = content.split("\n", 1)[-1] if "\n" in content else content[3:]
+            # Remove closing marker
+            if content.endswith("```"):
+                content = content[:-3]
+        return content.strip()
+
+canvas_service = CanvasService()