Update learning_platform.py

learning_platform.py

@@ -39,16 +39,17 @@ class LLMService:
         self.model = "gpt-4o"
         
     async def generate(self, prompt: str, temperature: float = 1.0) -> str:
-        try:
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=[{"role": "system", "content": prompt}],
-                temperature=temperature
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            st.error(f"LLM Error: {str(e)}")
-            return ""
+    try:
+        st.write("🤖 Calling OpenAI API...")
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=[{"role": "system", "content": prompt}],
+            temperature=temperature
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        st.error(f"OpenAI API error: {str(e)}")
+        raise
 
 class ContentGenerator:
     def __init__(self, llm_service: LLMService):
@@ -107,33 +108,21 @@ class LearningPlatform:
         self.llm_service = LLMService(api_key)
         self.content_generator = ContentGenerator(self.llm_service)
 
-    async def create_module(self, module: LearningModule, topic: str):
-        try:
-            sections_prompt = f"List 3-4 section titles for module '{module.title}' in {topic}. Return JSON array of strings."
-            section_titles = json.loads(await self.llm_service.generate(sections_prompt))
-            
-            for title in section_titles:
-                section = await self.content_generator.generate_section_content(topic, title)
-                module.sections.append(section)
-            
-            module.is_complete = True
-            return module
-        except Exception as e:
-            st.error(f"Module generation error: {str(e)}")
-            raise
-
-    async def generate_remaining_modules(self, path: LearningPath, topic: str):
-        for module in path.modules[1:]:
-            await self.create_module(module, topic)
-        path.is_generating = False
-
     async def create_course(self, topic: str, difficulty: str) -> LearningPath:
         try:
-            titles_prompt = f"List 3-5 module titles for {topic} course. Return JSON array of strings."
-            titles = json.loads(await self.llm_service.generate(titles_prompt))
+            st.write("🔍 Generating course outline...")
+            titles_prompt = f"List 3 module titles for {topic} course. Return as JSON array of strings."
+            titles_task = asyncio.create_task(self.llm_service.generate(titles_prompt))
             
-            modules = [LearningModule(title=title) for title in titles]
+            try:
+                titles_response = await asyncio.wait_for(titles_task, timeout=30)
+                titles = json.loads(titles_response)
+            except asyncio.TimeoutError:
+                st.error("Timeout generating course outline")
+                raise
             
+            st.write("📚 Creating course structure...")
+            modules = [LearningModule(title=title) for title in titles]
             path = LearningPath(
                 topic=topic,
                 description=f"Course on {topic}",
@@ -142,14 +131,48 @@ class LearningPlatform:
                 difficulty_level=difficulty
             )
             
-            # Generate first module
-            await self.create_module(path.modules[0], topic)
+            st.write("🎯 Generating first module...")
+            try:
+                await asyncio.wait_for(
+                    self.create_module(path.modules[0], topic),
+                    timeout=60
+                )
+            except asyncio.TimeoutError:
+                st.error("Timeout generating first module")
+                raise
             
-            # Generate rest in background
+            st.write("✨ Starting background generation...")
             asyncio.create_task(self.generate_remaining_modules(path, topic))
             
             return path
             
         except Exception as e:
-            st.error(f"Course creation error: {str(e)}")
-            raise
+            st.error(f"Course creation failed: {str(e)}")
+            raise
+
+    async def create_module(self, module: LearningModule, topic: str, timeout: int = 30):
+        try:
+            st.write(f"Generating sections for {module.title}...")
+            sections_prompt = f"List 3 section titles for module '{module.title}' in {topic}. Return JSON array."
+            
+            section_titles = json.loads(await asyncio.wait_for(
+                self.llm_service.generate(sections_prompt),
+                timeout=timeout
+            ))
+            
+            for title in section_titles:
+                st.write(f"Creating section: {title}")
+                section = await self.content_generator.generate_section_content(topic, title)
+                module.sections.append(section)
+            
+            module.is_complete = True
+            return module
+        except Exception as e:
+            st.error(f"Module generation failed: {str(e)}")
+            raise
+
+    async def generate_remaining_modules(self, path: LearningPath, topic: str):
+        for i, module in enumerate(path.modules[1:], 1):
+            st.write(f"Generating module {i+1} of {len(path.modules)}...")
+            await self.create_module(module, topic)
+        path.is_generating = False