Update app.py

app.py

@@ -1723,7 +1723,177 @@ You consider all perspectives: producers, actors, audience.
 You provide feedback that's critical yet encouraging."""
             }
         }
+        
+        return base_prompts.get(language, base_prompts["English"])
+
+
+
+# --- Main process ---
+    def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
+                                language: str, session_id: Optional[str] = None
+                                ) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
+        """Main screenplay generation process"""
+        try:
+            resume_from_stage = 0
+            if session_id:
+                self.current_session_id = session_id
+                session = ScreenplayDatabase.get_session(session_id)
+                if session:
+                    query = session['user_query']
+                    screenplay_type = session['screenplay_type']
+                    genre = session['genre']
+                    language = session['language']
+                    resume_from_stage = session['current_stage'] + 1
+            else:
+                self.current_session_id = ScreenplayDatabase.create_session(
+                    query, screenplay_type, genre, language
+                )
+                logger.info(f"Created new screenplay session: {self.current_session_id}")
+
+            stages = []
+            if resume_from_stage > 0:
+                # Get existing stages from database
+                db_stages = ScreenplayDatabase.get_stages(self.current_session_id)
+                stages = [{
+                    "name": s['stage_name'], 
+                    "status": s['status'], 
+                    "content": s.get('content', ''),
+                    "page_count": s.get('page_count', 0)
+                } for s in db_stages]
+
+            for stage_idx in range(resume_from_stage, len(SCREENPLAY_STAGES)):
+                role, stage_name = SCREENPLAY_STAGES[stage_idx]
+                
+                if stage_idx >= len(stages):
+                    stages.append({
+                        "name": stage_name, 
+                        "status": "active", 
+                        "content": "", 
+                        "page_count": 0
+                    })
+                else:
+                    stages[stage_idx]["status"] = "active"
+
+                yield f"🔄 Processing {stage_name}...", stages, self.current_session_id
+                
+                prompt = self.get_stage_prompt(stage_idx, role, query, screenplay_type, 
+                                             genre, language, stages)
+                stage_content = ""
+                
+                for chunk in self.call_llm_streaming([{"role": "user", "content": prompt}], 
+                                                   role, language):
+                    stage_content += chunk
+                    stages[stage_idx]["content"] = stage_content
+                    if role == "screenwriter":
+                        stages[stage_idx]["page_count"] = len(stage_content.split('\n')) / 55
+                    yield f"🔄 {stage_name} in progress...", stages, self.current_session_id
+
+                # Process content based on role
+                if role == "producer":
+                    self._process_producer_content(stage_content)
+                elif role == "story_developer":
+                    self._process_story_content(stage_content)
+                elif role == "character_designer":
+                    self._process_character_content(stage_content)
+                elif role == "scene_planner":
+                    self._process_scene_content(stage_content)
+
+                stages[stage_idx]["status"] = "complete"
+                ScreenplayDatabase.save_stage(
+                    self.current_session_id, stage_idx, stage_name, role,
+                    stage_content, "complete"
+                )
+                
+                yield f"✅ {stage_name} completed", stages, self.current_session_id
+
+            # Final processing
+            final_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
+            title = self.screenplay_tracker.screenplay_bible.title
+            logline = self.screenplay_tracker.screenplay_bible.logline
+            
+            ScreenplayDatabase.update_final_screenplay(
+                self.current_session_id, final_screenplay, title, logline
+            )
+            
+            yield f"✅ Screenplay completed! {title}", stages, self.current_session_id
+
+        except Exception as e:
+            logger.error(f"Screenplay generation error: {e}", exc_info=True)
+            yield f"❌ Error occurred: {e}", stages if 'stages' in locals() else [], self.current_session_id
+
+    def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
+                        screenplay_type: str, genre: str, language: str, 
+                        stages: List[Dict]) -> str:
+        """Generate stage-specific prompt"""
+        if stage_idx == 0:  # Producer
+            return self.create_producer_prompt(query, screenplay_type, genre, language)
+        
+        if stage_idx == 1:  # Story Developer
+            return self.create_story_developer_prompt(
+                stages[0]["content"], query, screenplay_type, genre, language
+            )
+        
+        if stage_idx == 2:  # Character Designer
+            return self.create_character_designer_prompt(
+                stages[0]["content"], stages[1]["content"], genre, language
+            )
+        
+        if stage_idx == 3:  # Structure Critic
+            return self.create_critic_structure_prompt(
+                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
+            )
+        
+        if stage_idx == 4:  # Scene Planner
+            return self.create_scene_planner_prompt(
+                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
+            )
+        
+        # Screenwriter acts
+        if role == "screenwriter":
+            act_mapping = {5: "Act 1", 7: "Act 2A", 9: "Act 2B", 11: "Act 3"}
+            if stage_idx in act_mapping:
+                act = act_mapping[stage_idx]
+                previous_acts = self._get_previous_acts(stages, stage_idx)
+                return self.create_screenwriter_prompt(
+                    act, stages[4]["content"], stages[2]["content"], 
+                    previous_acts, screenplay_type, genre, language
+                )
+        
+        # Script doctor reviews
+        if role == "script_doctor":
+            act_mapping = {6: "Act 1", 8: "Act 2A", 10: "Act 2B"}
+            if stage_idx in act_mapping:
+                act = act_mapping[stage_idx]
+                act_content = stages[stage_idx-1]["content"]
+                return self.create_script_doctor_prompt(act_content, act, genre, language)
+        
+        # Final reviewer
+        if role == "final_reviewer":
+            complete_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
+            return self.create_final_reviewer_prompt(
+                complete_screenplay, screenplay_type, genre, language
+            )
+        
+        return ""
+
+    def _get_previous_acts(self, stages: List[Dict], current_idx: int) -> str:
+        """Get previous acts content"""
+        previous = []
+        act_indices = {5: [], 7: [5], 9: [5, 7], 11: [5, 7, 9]}
+        
+        if current_idx in act_indices:
+            for idx in act_indices[current_idx]:
+                if idx < len(stages) and stages[idx]["content"]:
+                    previous.append(stages[idx]["content"])
+        
+        return "\n\n---\n\n".join(previous) if previous else ""
+
+
+
+
 
+    
+    
     def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
        """Parse character profile from content"""
        # Extract character details using regex or string parsing