Update app.py

app.py

@@ -1503,7 +1503,15 @@ Provide specific solutions for each issue."""
             )
             
             if response.status_code != 200:
-                yield f"❌ API Error (Status Code: {response.status_code})"
+                error_msg = f"API Error (Status Code: {response.status_code})"
+                try:
+                    error_data = response.json()
+                    if isinstance(error_data, dict) and 'error' in error_data:
+                        error_msg += f" - {error_data['error']}"
+                except:
+                    error_msg += f" - {response.text}"
+                logger.error(error_msg)
+                yield f"❌ {error_msg}"
                 return
             
             buffer = ""
@@ -1516,32 +1524,49 @@ Provide specific solutions for each issue."""
                     if not line_str.startswith("data: "):
                         continue
                     
-                    data_str = line_str[6:]
+                    data_str = line_str[6:]  # Remove "data: " prefix
                     if data_str == "[DONE]":
                         break
                     
-                    data = json.loads(data_str)
-                    choices = data.get("choices", [])
-                    if choices and choices[0].get("delta", {}).get("content"):
-                        content = choices[0]["delta"]["content"]
-                        buffer += content
-                        
-                        if len(buffer) >= 50 or '\n' in buffer:
-                            yield buffer
-                            buffer = ""
-                            time.sleep(0.01)
+                    # Parse JSON data
+                    try:
+                        data = json.loads(data_str)
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"JSON decode error: {e}, data: {data_str}")
+                        continue
+                    
+                    # Safely check for content
+                    if data and isinstance(data, dict):
+                        choices = data.get("choices", [])
+                        if choices and len(choices) > 0:
+                            delta = choices[0].get("delta", {})
+                            if delta and isinstance(delta, dict):
+                                content = delta.get("content", "")
+                                if content:
+                                    buffer += content
+                                    
+                                    if len(buffer) >= 50 or '\n' in buffer:
+                                        yield buffer
+                                        buffer = ""
+                                        time.sleep(0.01)
                     
                 except Exception as e:
-                    logger.error(f"Chunk processing error: {str(e)}")
+                    logger.error(f"Chunk processing error: {str(e)}, line: {line_str[:100]}")
                     continue
             
+            # Yield any remaining buffer content
             if buffer:
                 yield buffer
                 
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request error: {type(e).__name__}: {str(e)}")
+            yield f"❌ Network error: {str(e)}"
         except Exception as e:
             logger.error(f"Streaming error: {type(e).__name__}: {str(e)}")
             yield f"❌ Error occurred: {str(e)}"
 
+
+
     def get_system_prompts(self, language: str) -> Dict[str, str]:
         """Role-specific system prompts"""
         
@@ -1903,22 +1928,29 @@ You provide feedback that's critical yet encouraging."""
 
 # --- Utility functions ---
 def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
-   """Generate random screenplay theme"""
-   try:
-       # Load themes data
-       themes_data = load_screenplay_themes_data()
-       
-       # Select random elements
-       import secrets
-       situation = secrets.choice(themes_data['situations'].get(genre, themes_data['situations']['drama']))
-       protagonist = secrets.choice(themes_data['protagonists'].get(genre, themes_data['protagonists']['drama']))
-       conflict = secrets.choice(themes_data['conflicts'].get(genre, themes_data['conflicts']['drama']))
-       
-       # Generate theme using LLM
-       system = ScreenplayGenerationSystem()
-       
-       if language == "Korean":
-           prompt = f"""다음 요소들로 {screenplay_type}용 매력적인 컨셉을 생성하세요:
+    """Generate random screenplay theme"""
+    try:
+        # Load themes data
+        themes_data = load_screenplay_themes_data()
+        
+        # Select random elements
+        import secrets
+        situations = themes_data['situations'].get(genre, themes_data['situations']['drama'])
+        protagonists = themes_data['protagonists'].get(genre, themes_data['protagonists']['drama'])
+        conflicts = themes_data['conflicts'].get(genre, themes_data['conflicts']['drama'])
+        
+        if not situations or not protagonists or not conflicts:
+            return f"Error: No theme data available for genre {genre}"
+        
+        situation = secrets.choice(situations)
+        protagonist = secrets.choice(protagonists)
+        conflict = secrets.choice(conflicts)
+        
+        # Generate theme using LLM
+        system = ScreenplayGenerationSystem()
+        
+        if language == "Korean":
+            prompt = f"""다음 요소들로 {screenplay_type}용 매력적인 컨셉을 생성하세요:
 
 상황: {situation}
 주인공: {protagonist}
@@ -1934,8 +1966,8 @@ def generate_random_screenplay_theme(screenplay_type: str, genre: str, language:
 **컨셉:** [주인공]이(가) [상황]에서 [갈등]을 겪으며 [목표]를 추구하는 이야기.
 
 **독특한 요소:** [이 이야기만의 특별한 점]"""
-       else:
-           prompt = f"""Generate an attractive concept for {screenplay_type} using these elements:
+        else:
+            prompt = f"""Generate an attractive concept for {screenplay_type} using these elements:
 
 Situation: {situation}
 Protagonist: {protagonist}  
@@ -1952,28 +1984,61 @@ Format as:
 
 **Unique Element:** [What makes this story special]"""
 
-       messages = [{"role": "user", "content": prompt}]
-       generated_theme = system.call_llm_sync(messages, "producer", language)
-       
-       # Extract metadata
-       metadata = {
-           'title': extract_title_from_theme(generated_theme),
-           'logline': extract_logline_from_theme(generated_theme),
-           'protagonist': protagonist,
-           'conflict': conflict,
-           'tags': [genre, screenplay_type]
-       }
-       
-       # Save to database
-       theme_id = ScreenplayDatabase.save_random_theme(
-           generated_theme, screenplay_type, genre, language, metadata
-       )
-       
-       return generated_theme
-       
-   except Exception as e:
-       logger.error(f"Theme generation error: {str(e)}")
-       return f"Error generating theme: {str(e)}"
+        messages = [{"role": "user", "content": prompt}]
+        
+        # Call LLM with error handling
+        try:
+            generated_theme = system.call_llm_sync(messages, "producer", language)
+            
+            # Check if we got an error response
+            if generated_theme.startswith("❌"):
+                logger.error(f"LLM error: {generated_theme}")
+                # Return a fallback theme
+                return get_fallback_theme(screenplay_type, genre, language, situation, protagonist, conflict)
+            
+            # Extract metadata
+            metadata = {
+                'title': extract_title_from_theme(generated_theme),
+                'logline': extract_logline_from_theme(generated_theme),
+                'protagonist': protagonist,
+                'conflict': conflict,
+                'tags': [genre, screenplay_type]
+            }
+            
+            # Save to database
+            theme_id = ScreenplayDatabase.save_random_theme(
+                generated_theme, screenplay_type, genre, language, metadata
+            )
+            
+            return generated_theme
+            
+        except Exception as e:
+            logger.error(f"LLM call failed: {e}")
+            return get_fallback_theme(screenplay_type, genre, language, situation, protagonist, conflict)
+        
+    except Exception as e:
+        logger.error(f"Theme generation error: {str(e)}")
+        return f"Error generating theme: {str(e)}"
+
+def get_fallback_theme(screenplay_type: str, genre: str, language: str, 
+                      situation: str, protagonist: str, conflict: str) -> str:
+    """Generate fallback theme without LLM"""
+    if language == "Korean":
+        return f"""**제목:** {protagonist}의 선택
+
+**로그라인:** {situation}에 갇힌 {protagonist}가 {conflict}에 맞서며 생존을 위해 싸운다.
+
+**컨셉:** {protagonist}가 {situation}에서 {conflict}을 겪으며 자신의 한계를 극복하는 이야기.
+
+**독특한 요소:** {genre} 장르의 전통적 요소를 현대적으로 재해석한 작품."""
+    else:
+        return f"""**Title:** The {protagonist.title()}'s Choice
+
+**Logline:** When trapped in {situation}, a {protagonist} must face {conflict} to survive.
+
+**Concept:** A story about a {protagonist} who faces {conflict} in {situation} while discovering their true strength.
+
+**Unique Element:** A fresh take on {genre} genre conventions with contemporary relevance."""
 
 def load_screenplay_themes_data() -> Dict:
    """Load screenplay themes data"""