Upload creative_analyzer.py

src/analysis/creative_analyzer.py

@@ -0,0 +1,293 @@
+import os
+from pathlib import Path
+import logging
+from tqdm import tqdm
+import requests
+from src.analysis.analysis_cleaner import AnalysisCleaner
+
+logger = logging.getLogger(__name__)
+
+class CreativeAnalyzer:
+    def __init__(self):
+        # Initialize Claude
+        self.api_key = os.getenv("ANTHROPIC_API_KEY")
+        if not self.api_key:
+            raise ValueError("ANTHROPIC_API_KEY not found")
+
+        self.api_url = "https://api.anthropic.com/v1/messages"
+        self.model = "claude-3-sonnet-20240229"
+        self.headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json"
+        }
+
+        # Set chunk size
+        self.chunk_size = 6000  # Claude handles larger chunks well
+
+    def query_claude(self, prompt: str) -> str:
+        """Send request to Claude API with proper response handling"""
+        try:
+            payload = {
+                "model": self.model,
+                "max_tokens": 4096,
+                "messages": [{
+                    "role": "user",
+                    "content": prompt
+                }]
+            }
+
+            response = requests.post(self.api_url, headers=self.headers, json=payload)
+
+            if response.status_code == 200:
+                response_json = response.json()
+                # Get the message content from Claude's response
+                if ('content' in response_json and 
+                    isinstance(response_json['content'], list) and 
+                    len(response_json['content']) > 0 and
+                    'text' in response_json['content'][0]):
+                    return response_json['content'][0]['text']
+                else:
+                    logger.error("Invalid response structure")
+                    logger.error(f"Response: {response_json}")
+                    return None
+            else:
+                logger.error(f"API Error: {response.status_code}")
+                logger.error(f"Response: {response.text}")
+                return None
+
+        except Exception as e:
+            logger.error(f"Error making API request: {str(e)}")
+            logger.error("Full error details:", exc_info=True)
+            return None
+
+    def count_tokens(self, text: str) -> int:
+        """Estimate token count using simple word-based estimation"""
+        words = text.split()
+        return int(len(words) * 1.3)
+
+    def chunk_screenplay(self, text: str) -> list:
+        """Split screenplay into chunks with overlap for context"""
+        logger.info("Chunking screenplay...")
+
+        scenes = text.split("\n\n")
+        chunks = []
+        current_chunk = []
+        current_size = 0
+        overlap_scenes = 2
+
+        for scene in scenes:
+            scene_size = self.count_tokens(scene)
+
+            if current_size + scene_size > self.chunk_size and current_chunk:
+                overlap = current_chunk[-overlap_scenes:] if len(current_chunk) > overlap_scenes else current_chunk
+                chunks.append("\n\n".join(current_chunk))
+                current_chunk = overlap + [scene]
+                current_size = sum(self.count_tokens(s) for s in current_chunk)
+            else:
+                current_chunk.append(scene)
+                current_size += scene_size
+
+        if current_chunk:
+            chunks.append("\n\n".join(current_chunk))
+
+        logger.info(f"Split screenplay into {len(chunks)} chunks with {overlap_scenes} scene overlap")
+        return chunks
+
+    def analyze_plot_development(self, chunk: str, previous_plot_points: str = "") -> str:
+        prompt = f"""You are a professional screenplay analyst. Building on this previous analysis:
+{previous_plot_points}
+
+Continue analyzing the story's progression. Tell me what happens next, focusing on new developments and changes. Reference specific moments from this section but don't repeat what we've covered.
+
+Consider:
+- How events build on what came before
+- Their impact on story direction
+- Changes to the narrative
+
+Use flowing paragraphs and support with specific examples.
+
+Screenplay section to analyze:
+{chunk}"""
+
+        return self.query_claude(prompt)
+
+    def analyze_character_arcs(self, chunk: str, plot_context: str, previous_character_dev: str = "") -> str:
+        prompt = f"""You are a professional screenplay analyst. Based on these plot developments:
+{plot_context}
+
+And previous character analysis:
+{previous_character_dev}
+
+Continue analyzing how the characters evolve. Focus on their growth, changes, and key moments from this section. Build on, don't repeat, previous analysis.
+
+Consider:
+- Character choices and consequences
+- Relationship dynamics
+- Internal conflicts and growth
+
+Use flowing paragraphs with specific examples.
+
+Screenplay section to analyze:
+{chunk}"""
+
+        return self.query_claude(prompt)
+
+    def analyze_dialogue_progression(self, chunk: str, character_context: str, previous_dialogue: str = "") -> str:
+        prompt = f"""You are a professional screenplay analyst. Understanding the character context:
+{character_context}
+
+And previous dialogue analysis:
+{previous_dialogue}
+
+Analyze the dialogue in this section from a screenwriting perspective. What makes it effective or distinctive?
+
+Consider:
+- How dialogue reveals character
+- Subtext and meaning
+- Character voices and patterns
+- Impact on relationships
+
+Use specific dialogue examples in flowing paragraphs.
+
+Screenplay section to analyze:
+{chunk}"""
+
+        return self.query_claude(prompt)
+
+    def analyze_themes(self, chunk: str, plot_context: str, character_context: str) -> str:
+        prompt = f"""You are a professional screenplay analyst. Based on these plot developments:
+{plot_context}
+
+And character journeys:
+{character_context}
+
+Analyze how themes develop in this section. What deeper meanings emerge? How do they connect to previous themes?
+
+Consider:
+- Core ideas and messages
+- Symbolic elements
+- How themes connect to character arcs
+- Social or philosophical implications
+
+Support with specific examples in flowing paragraphs.
+
+Screenplay section to analyze:
+{chunk}"""
+
+        return self.query_claude(prompt)
+
+    def analyze_screenplay(self, screenplay_path: Path) -> bool:
+        """Main method to generate creative analysis"""
+        logger.info("Starting creative analysis")
+
+        try:
+            # Read screenplay
+            with open(screenplay_path, 'r', encoding='utf-8') as file:
+                screenplay_text = file.read()
+
+            # Split into chunks
+            chunks = self.chunk_screenplay(screenplay_text)
+
+            # Initialize analyses
+            plot_analysis = []
+            character_analysis = []
+            dialogue_analysis = []
+            theme_analysis = []
+
+            # First Pass: Plot Development
+            logger.info("First Pass: Analyzing plot development")
+            with tqdm(total=len(chunks), desc="Analyzing plot") as pbar:
+                for chunk in chunks:
+                    result = self.analyze_plot_development(
+                        chunk,
+                        "\n\n".join(plot_analysis)
+                    )
+                    if result:
+                        plot_analysis.append(result)
+                    else:
+                        logger.error("Failed to get plot analysis")
+                        return False
+                    pbar.update(1)
+
+            # Second Pass: Character Arcs
+            logger.info("Second Pass: Analyzing character arcs")
+            with tqdm(total=len(chunks), desc="Analyzing characters") as pbar:
+                for chunk in chunks:
+                    result = self.analyze_character_arcs(
+                        chunk,
+                        "\n\n".join(plot_analysis),
+                        "\n\n".join(character_analysis)
+                    )
+                    if result:
+                        character_analysis.append(result)
+                    else:
+                        logger.error("Failed to get character analysis")
+                        return False
+                    pbar.update(1)
+
+            # Third Pass: Dialogue Progression
+            logger.info("Third Pass: Analyzing dialogue")
+            with tqdm(total=len(chunks), desc="Analyzing dialogue") as pbar:
+                for chunk in chunks:
+                    result = self.analyze_dialogue_progression(
+                        chunk,
+                        "\n\n".join(character_analysis),
+                        "\n\n".join(dialogue_analysis)
+                    )
+                    if result:
+                        dialogue_analysis.append(result)
+                    else:
+                        logger.error("Failed to get dialogue analysis")
+                        return False
+                    pbar.update(1)
+
+            # Fourth Pass: Thematic Development
+            logger.info("Fourth Pass: Analyzing themes")
+            with tqdm(total=len(chunks), desc="Analyzing themes") as pbar:
+                for chunk in chunks:
+                    result = self.analyze_themes(
+                        chunk,
+                        "\n\n".join(plot_analysis),
+                        "\n\n".join(character_analysis)
+                    )
+                    if result:
+                        theme_analysis.append(result)
+                    else:
+                        logger.error("Failed to get theme analysis")
+                        return False
+                    pbar.update(1)
+
+            # Clean up analyses
+            cleaner = AnalysisCleaner()
+            cleaned_analyses = {
+                'plot': cleaner.clean_analysis("\n\n".join(plot_analysis)),
+                'character': cleaner.clean_analysis("\n\n".join(character_analysis)),
+                'dialogue': cleaner.clean_analysis("\n\n".join(dialogue_analysis)),
+                'theme': cleaner.clean_analysis("\n\n".join(theme_analysis))
+            }
+
+            # Save Analysis
+            output_path = screenplay_path.parent / "creative_analysis.txt"
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write("SCREENPLAY CREATIVE ANALYSIS\n\n")
+
+                sections = [
+                    ("PLOT PROGRESSION", cleaned_analyses['plot']),
+                    ("CHARACTER ARCS", cleaned_analyses['character']),
+                    ("DIALOGUE PROGRESSION", cleaned_analyses['dialogue']),
+                    ("THEMATIC DEVELOPMENT", cleaned_analyses['theme'])
+                ]
+
+                for title, content in sections:
+                    f.write(f"### {title} ###\n\n")
+                    f.write(content)
+                    f.write("\n\n")
+
+            logger.info(f"Analysis saved to: {output_path}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error in creative analysis: {str(e)}")
+            logger.error("Full error details:", exc_info=True)
+            return False