fix: build fix

Author: codiphile

backend/app/main.py

@@ -1,16 +1,16 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
 import json
 import uuid
-from typing import Dict, List, Optional
-import asyncio
 
-from .websockets.room_manager import RoomManager
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+
+from .models.classroom import ClassroomCreate
 from .websockets.chat_handler import ChatHandler
-from .models.classroom import Classroom, ClassroomCreate
+from .websockets.room_manager import RoomManager
 
-app = FastAPI(title="Instructify API", description="EdTech Platform with AI-powered features")
+app = FastAPI(
+    title="Instructify API", description="EdTech Platform with AI-powered features"
+)
 
 # CORS middleware for Next.js frontend
 app.add_middleware(
@@ -25,22 +25,26 @@
 room_manager = RoomManager()
 chat_handler = ChatHandler(room_manager)
 
+
 @app.get("/")
 async def root():
     return {"message": "Instructify API is running"}
 
+
 @app.get("/health")
 async def health():
     return {"status": "healthy"}
 
+
 # Classroom management endpoints
 @app.post("/api/classroom/create")
 async def create_classroom(classroom_data: ClassroomCreate):
     """Create a new classroom and return classroom ID"""
     class_id = str(uuid.uuid4())[:8]  # Short ID for easy sharing
-    classroom = await room_manager.create_room(class_id, classroom_data.teacher_name)
+    await room_manager.create_room(class_id, classroom_data.teacher_name)
     return {"class_id": class_id, "teacher_name": classroom_data.teacher_name}
 
+
 @app.get("/api/classroom/{class_id}")
 async def get_classroom(class_id: str):
     """Get classroom information"""
@@ -49,42 +53,49 @@ async def get_classroom(class_id: str):
         raise HTTPException(status_code=404, detail="Classroom not found")
     return classroom.dict()
 
+
 @app.websocket("/ws/classroom/{class_id}")
 async def websocket_endpoint(websocket: WebSocket, class_id: str):
     """Main WebSocket endpoint for classroom communication"""
     await websocket.accept()
-    
+
     try:
         # Wait for initial message to determine user type (teacher/student)
         data = await websocket.receive_text()
         message = json.loads(data)
-        
+
         user_type = message.get("user_type")  # "teacher" or "student"
         user_name = message.get("user_name", "Anonymous")
-        
+
         # Add user to room
         await room_manager.add_user_to_room(class_id, websocket, user_type, user_name)
-        
+
         # Send confirmation
-        await websocket.send_text(json.dumps({
-            "type": "connection_confirmed",
-            "user_type": user_type,
-            "class_id": class_id
-        }))
-        
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "connection_confirmed",
+                    "user_type": user_type,
+                    "class_id": class_id,
+                }
+            )
+        )
+
         # Handle incoming messages
         while True:
             data = await websocket.receive_text()
             message = json.loads(data)
-            
+
             await chat_handler.handle_message(class_id, websocket, message)
-            
+
     except WebSocketDisconnect:
         await room_manager.remove_user_from_room(class_id, websocket)
     except Exception as e:
         print(f"WebSocket error: {e}")
         await websocket.close()
 
+
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

backend/app/services/ollama_client.py

@@ -1,140 +1,151 @@
-import httpx
 import json
-from typing import Optional, Dict, Any
-import asyncio
+from typing import Any, Dict, Optional
+
+import httpx
+
 
 class OllamaClient:
     """Client for interacting with Ollama local LLM server"""
-    
+
     def __init__(self, base_url: str = "http://localhost:11434"):
         self.base_url = base_url
         self.model_name = "Instructify"
-    
+
     async def is_available(self) -> bool:
         """Check if Ollama server is available"""
         try:
             async with httpx.AsyncClient() as client:
                 response = await client.get(f"{self.base_url}/api/tags")
                 return response.status_code == 200
-        except:
+        except Exception:
             return False
-    
+
     async def generate_text(self, prompt: str, context: str = "") -> Optional[str]:
         """Generate text using Gemma 270M model"""
         try:
             full_prompt = f"{context}\n\n{prompt}" if context else prompt
-            
+
             async with httpx.AsyncClient(timeout=30.0) as client:
                 response = await client.post(
                     f"{self.base_url}/api/generate",
                     json={
                         "model": self.model_name,
                         "prompt": full_prompt,
-                        "stream": False
-                    }
+                        "stream": False,
+                    },
                 )
-                
+
                 if response.status_code == 200:
                     result = response.json()
-                    return result.get("response", "").strip()
+                    response_text = result.get("response", "")
+                    return str(response_text).strip() if response_text else None
                 else:
                     print(f"Ollama error: {response.status_code}")
                     return None
-                    
+
         except Exception as e:
             print(f"Ollama client error: {e}")
             return None
-    
+
     async def generate_notes(self, transcription: str) -> Optional[str]:
         """Generate structured notes from class transcription"""
-        prompt = """Please create structured class notes from the following transcription. 
-        Format the response as markdown with the following sections:
-        
+        prompt = """Please create structured class notes from the transcription.
+        Format the response as markdown with these sections:
+
         ## Summary
         [Brief overview of the class]
-        
+
         ## Key Topics
         [Main topics covered with bullet points]
-        
+
         ## Important Definitions
         [Key terms and their definitions]
-        
+
         ## Action Items
         [Any assignments or tasks mentioned]
-        
+
         ## Questions for Review
         [3-5 review questions based on the content]
-        
+
         Transcription:
         """
-        
+
         return await self.generate_text(prompt, transcription)
-    
+
     async def classify_doubt(self, message: str, context: str = "") -> Dict[str, Any]:
         """Classify if a message is a genuine doubt that should go to teacher"""
-        prompt = f"""Analyze this student message and determine if it's a genuine academic doubt that should be forwarded to the teacher.
-        
+        prompt = f"""Analyze this student message and determine if it's a genuine
+        academic doubt that should be forwarded to the teacher.
+
         Context: {context}
-        
+
         Student message: "{message}"
-        
+
         Respond in JSON format with:
         {{
             "is_genuine_doubt": true/false,
             "confidence": 0.0-1.0,
             "reason": "brief explanation",
             "category": "academic_question|personal_ai_query|spam|off_topic"
         }}
-        
+
         Only classify as "genuine_doubt" if it's:
         - A specific academic question about the subject
         - Request for clarification on course material
         - Question about assignments or course logistics
-        
+
         Do NOT classify as genuine_doubt if it's:
         - General knowledge questions
         - Personal queries to AI
         - Off-topic discussions
         - Spam or inappropriate content
         """
-        
+
         try:
             response = await self.generate_text(prompt)
             if response:
                 # Try to extract JSON from response
                 import re
-                json_match = re.search(r'\{.*\}', response, re.DOTALL)
+
+                json_match = re.search(r"\{.*\}", response, re.DOTALL)
                 if json_match:
-                    return json.loads(json_match.group())
-            
+                    parsed_json = json.loads(json_match.group())
+                    if isinstance(parsed_json, dict):
+                        return parsed_json
+                    return {}
+
             # Fallback response
             return {
                 "is_genuine_doubt": False,
                 "confidence": 0.5,
                 "reason": "Could not analyze message",
-                "category": "unknown"
+                "category": "unknown",
             }
-            
+
         except Exception as e:
             print(f"Error classifying doubt: {e}")
             return {
                 "is_genuine_doubt": False,
                 "confidence": 0.0,
                 "reason": "Analysis failed",
-                "category": "error"
+                "category": "error",
             }
-    
-    async def answer_student_query(self, query: str, lecture_context: str = "") -> Optional[str]:
+
+    async def answer_student_query(
+        self, query: str, lecture_context: str = ""
+    ) -> Optional[str]:
         """Answer student query using lecture context"""
-        prompt = f"""You are an AI teaching assistant. Answer the student's question based on the lecture context provided.
-        
+        prompt = f"""You are an AI teaching assistant. Answer the student's
+        question based on the lecture context provided.
+
         Lecture Context:
         {lecture_context}
-        
+
         Student Question: {query}
-        
-        Provide a helpful, educational response. If the question is outside the lecture scope, 
-        provide general guidance and suggest asking the teacher for more specific help.
+
+        Provide a helpful, educational response. If the question is outside
+        the lecture scope, provide general guidance and suggest asking the
+        teacher for more specific help.
         """
-        
+
         return await self.generate_text(prompt)

backend/app/utils/auth.py

@@ -1,20 +1,20 @@
-from typing import Optional
 import uuid
 
+
 class SimpleAuth:
     """Simple authentication helper for prototype"""
-    
+
     @staticmethod
     def generate_session_id() -> str:
         """Generate a simple session ID"""
         return str(uuid.uuid4())
-    
+
     @staticmethod
     def validate_user_type(user_type: str) -> bool:
         """Validate user type"""
         return user_type in ["teacher", "student"]
-    
+
     @staticmethod
     def generate_class_id() -> str:
         """Generate a short, shareable class ID"""
-        return str(uuid.uuid4())[:8].upper()
+        return str(uuid.uuid4())[:8].upper()