Update app.py

app.py

@@ -3,6 +3,7 @@ import openai
 import os
 from dotenv import load_dotenv
 from typing import Dict, List
+import json
 
 # Load environment variables
 load_dotenv()
@@ -21,39 +22,13 @@ class ForensicAgent:
     def __init__(self, role: str, expertise: str):
         self.role = role
         self.expertise = expertise
-        self.findings = []
     
     def analyze(self, text: str) -> Dict:
         """Perform analysis and return findings"""
         raise NotImplementedError
 
-class StylometricAgent(ForensicAgent):
-    """Analyzes writing style characteristics"""
-    def __init__(self):
-        super().__init__("Dr. Styles", "Stylometric Analysis Expert")
-    
-    def analyze(self, text: str) -> Dict:
-        prompt = f"""
-        As a {self.role}, {self.expertise}, analyze this text for stylometric patterns:
-        
-        {text}
-        
-        Evaluate:
-        1. Sentence length variation (human: high, AI: low)
-        2. Lexical diversity (human: contextual, AI: generic)
-        3. Punctuation usage patterns
-        4. Paragraph structure complexity
-        
-        Return findings in this format:
-        {{
-            "verdict": "Human/AI/Uncertain",
-            "confidence": "0-100%",
-            "evidence": ["list", "of", "key", "findings"]
-        }}
-        """
-        return self._get_analysis(prompt)
-    
     def _get_analysis(self, prompt: str) -> Dict:
+        """Generic OpenAI request handler"""
         try:
             if new_openai:
                 response = client.chat.completions.create(
@@ -65,7 +40,7 @@ class StylometricAgent(ForensicAgent):
                     temperature=0.1,
                     response_format={"type": "json_object"}
                 )
-                return eval(response.choices[0].message.content)
+                return json.loads(response.choices[0].message.content)
             else:
                 response = openai.ChatCompletion.create(
                     model="gpt-4",
@@ -76,9 +51,28 @@ class StylometricAgent(ForensicAgent):
                     temperature=0.1,
                     response_format={"type": "json_object"}
                 )
-                return eval(response['choices'][0]['message']['content'])
+                return json.loads(response['choices'][0]['message']['content'])
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": str(e), "verdict": "Error", "confidence": "0%"}
+
+class StylometricAgent(ForensicAgent):
+    """Analyzes writing style characteristics"""
+    def __init__(self):
+        super().__init__("Dr. Styles", "Stylometric Analysis Expert")
+    
+    def analyze(self, text: str) -> Dict:
+        prompt = f"""
+        Analyze this text for stylometric patterns:
+        {text}
+        
+        Return JSON with: verdict (Human/AI/Uncertain), confidence (0-100%), and evidence list.
+        Focus on:
+        - Sentence length variation
+        - Lexical diversity
+        - Punctuation patterns
+        - Paragraph structure
+        """
+        return self._get_analysis(prompt)
 
 class CognitiveAgent(ForensicAgent):
     """Analyzes cognitive and psychological markers"""
@@ -87,23 +81,15 @@ class CognitiveAgent(ForensicAgent):
     
     def analyze(self, text: str) -> Dict:
         prompt = f"""
-        As {self.role}, {self.expertise}, analyze this text for cognitive markers:
-        
+        Analyze this text for cognitive markers:
         {text}
         
-        Evaluate:
-        1. Presence of hedging language ("perhaps", "I think")
-        2. Use of personal pronouns and anecdotes
-        3. Emotional expression patterns
-        4. Confidence markers ("undoubtedly", "clearly")
-        5. Metacognitive statements ("I'm not sure but...")
-        
-        Return findings in this format:
-        {{
-            "verdict": "Human/AI/Uncertain",
-            "confidence": "0-100%",
-            "evidence": ["list", "of", "key", "findings"]
-        }}
+        Return JSON with: verdict (Human/AI/Uncertain), confidence (0-100%), and evidence list.
+        Focus on:
+        - Hedging language
+        - Personal pronouns/anecdotes
+        - Emotional expressions
+        - Confidence markers
         """
         return self._get_analysis(prompt)
 
@@ -114,23 +100,15 @@ class SemanticAgent(ForensicAgent):
     
     def analyze(self, text: str) -> Dict:
         prompt = f"""
-        As {self.role}, {self.expertise}, analyze this text for semantic patterns:
-        
+        Analyze this text for semantic patterns:
         {text}
         
-        Evaluate:
-        1. Metaphor and idiom density
-        2. Contextual anchoring (specific vs vague references)
-        3. Temporal references (specific dates vs generic time)
-        4. Cultural reference depth
-        5. Error patterns (typos vs semantic inconsistencies)
-        
-        Return findings in this format:
-        {{
-            "verdict": "Human/AI/Uncertain",
-            "confidence": "0-100%",
-            "evidence": ["list", "of", "key", "findings"]
-        }}
+        Return JSON with: verdict (Human/AI/Uncertain), confidence (0-100%), and evidence list.
+        Focus on:
+        - Metaphor/idiom density
+        - Contextual references
+        - Temporal references
+        - Error patterns
         """
         return self._get_analysis(prompt)
 
@@ -145,58 +123,46 @@ class ForensicCrew:
     
     def analyze_text(self, text: str) -> str:
         """Coordinate multi-agent analysis"""
-        if len(text.split()) < 30:
-            return "⚠️ Please provide at least 150 characters for accurate analysis."
+        if len(text.strip()) < 30:
+            return "⚠️ Please provide at least 50 characters for accurate analysis."
         
-        # Gather all agent findings
-        findings = [agent.analyze(text) for agent in self.agents]
-        
-        # Have the chief analyst synthesize the results
-        return self._synthesize_findings(text, findings)
-    
+        try:
+            # Get all agent findings
+            findings = []
+            for agent in self.agents:
+                result = agent.analyze(text)
+                findings.append(result)
+                if "error" in result:
+                    print(f"Agent {agent.role} error: {result['error']}")
+            
+            # Generate final report
+            return self._synthesize_findings(text, findings)
+        except Exception as e:
+            return f"🔴 System Error: {str(e)}"
+
     def _synthesize_findings(self, text: str, findings: List[Dict]) -> str:
-        """Have a chief analyst compile the final report"""
-        synthesis_prompt = f"""
-        [TEXT UNDER ANALYSIS]
-        {text}
-        
-        [AGENT FINDINGS]
-        {findings}
-        
-        As Chief Forensic Analyst Dr. Lexica, synthesize these findings into a comprehensive report:
-        
-        # 🕵️‍♂️ Forensic Text Analysis Report (CrewAI Approach)
-        
-        ## 🔍 Composite Verdict
-        **Origin:** {{Human/AI/Inconclusive}}  
-        **Confidence Level:** {{XX%}}  
-        
-        ## 📊 Agent Consensus
-        {self._format_agent_summary(findings)}
-        
-        ## 🧐 Detailed Findings
-        ### 1️⃣ Stylometric Evidence
-        {{Summary of stylometric findings}}
-        
-        ### 2️⃣ Cognitive Patterns
-        {{Summary of cognitive findings}}
-        
-        ### 3️⃣ Semantic Fingerprints
-        {{Summary of semantic findings}}
-        
-        ## 💡 Expert Conclusion
-        {{3-4 sentence authoritative conclusion synthesizing all evidence}}
-        
-        ⚠️ **Disclaimer:** This analysis combines multiple forensic techniques with {self._calculate_confidence(findings)}% consensus confidence.
-        """
-        
+        """Generate final report"""
         try:
+            prompt = f"""
+            Text under analysis:
+            {text}
+            
+            Agent findings:
+            {json.dumps(findings, indent=2)}
+            
+            Compile a forensic report with:
+            1. Composite verdict (Human/AI/Uncertain)
+            2. Confidence score (average of agent confidences)
+            3. Key evidence from each agent
+            4. Final conclusion
+            """
+            
             if new_openai:
                 response = client.chat.completions.create(
                     model="gpt-4",
                     messages=[
                         {"role": "system", "content": "You are Dr. Lexica, Chief Forensic Analyst."},
-                        {"role": "user", "content": synthesis_prompt}
+                        {"role": "user", "content": prompt}
                     ],
                     temperature=0.1,
                     max_tokens=800
@@ -207,34 +173,14 @@ class ForensicCrew:
                     model="gpt-4",
                     messages=[
                         {"role": "system", "content": "You are Dr. Lexica, Chief Forensic Analyst."},
-                        {"role": "user", "content": synthesis_prompt}
+                        {"role": "user", "content": prompt}
                     ],
                     temperature=0.1,
                     max_tokens=800
                 )
                 return response['choices'][0]['message']['content']
         except Exception as e:
-            return f"🔴 Analysis failed. Error: {str(e)}"
-    
-    def _format_agent_summary(self, findings: List[Dict]) -> str:
-        """Format agent findings for the report"""
-        summary = []
-        agent_names = ["Stylometric Analyst", "Cognitive Linguist", "Semantic Expert"]
-        
-        for idx, finding in enumerate(findings):
-            if "error" in finding:
-                summary.append(f"🔴 {agent_names[idx]}: Error - {finding['error']}")
-            else:
-                verdict = finding.get("verdict", "Unknown")
-                confidence = finding.get("confidence", "0%")
-                summary.append(f"🔵 {agent_names[idx]}: {verdict} ({confidence} confidence)")
-        
-        return "\n".join(summary)
-    
-    def _calculate_confidence(self, findings: List[Dict]) -> int:
-        """Calculate average confidence from valid agent responses"""
-        valid = [int(f.get("confidence", "0%").strip('%')) for f in findings if "error" not in f]
-        return sum(valid) // len(valid) if valid else 0
+            return f"🔴 Report Generation Failed: {str(e)}"
 
 # Initialize the forensic crew
 crew = ForensicCrew()
@@ -242,39 +188,44 @@ crew = ForensicCrew()
 # Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as app:
     gr.Markdown("""
-    # 🔬 AI/Human Text Forensic Analyzer (CrewAI Approach)
-    *Multi-agent forensic analysis combining stylometric, cognitive, and semantic techniques*
+    # 🔬 AI/Human Text Forensic Analyzer (CrewAI)
+    *Multi-agent analysis combining stylometric, cognitive, and semantic techniques*
     """)
     
     with gr.Row():
         with gr.Column():
-            input_text = gr.Textbox(label="📝 Text to Analyze", 
-                                 lines=7, 
-                                 placeholder="Paste any text (minimum 150 characters for accurate analysis)...",
-                                 elem_id="input_box")
+            input_text = gr.Textbox(
+                label="📝 Text to Analyze", 
+                lines=7,
+                placeholder="Paste any text (50+ characters recommended)..."
+            )
             with gr.Row():
                 analyze_btn = gr.Button("🧪 Analyze Text", variant="primary")
                 clear_btn = gr.Button("🔄 Clear")
         
         with gr.Column():
-            output_text = gr.Markdown(label="📜 CrewAI Analysis Report", 
-                                    elem_id="output_panel")
+            output_text = gr.Markdown(
+                label="📜 Forensic Analysis Report",
+                elem_classes=["output-panel"]
+            )
     
+    # Example texts
     gr.Examples(
         examples=[
-            ["Walking through the old cobblestone streets of Prague last summer, I was struck by how the golden light of dusk made the ancient buildings look like they were glowing from within - a memory that still makes me smile months later."],
-            ["The utilization of advanced neural network architectures enables the generation of coherent textual outputs through the application of transformer-based deep learning paradigms."],
-            ["Honestly, I'm not entirely sure about this whole thing. It seems kinda complicated to me, but maybe that's just because I've never been good with technology."]
+            ["The rain tapped gently against the window as I reminisced about childhood summers - those endless days that now seem like someone else's memory."],
+            ["Large language models utilize transformer architectures to generate human-like text through probabilistic prediction mechanisms."],
+            ["I dunno... it's kinda weird how phones these days track everything. Makes me uncomfortable tbh."]
         ],
         inputs=input_text,
-        label="💡 Try these examples:",
-        examples_per_page=3
+        label="💡 Try these examples:"
     )
     
+    # Button actions
     analyze_btn.click(
         fn=crew.analyze_text,
         inputs=input_text,
-        outputs=output_text
+        outputs=output_text,
+        api_name="analyze"
     )
     
     clear_btn.click(
@@ -283,4 +234,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as app:
         outputs=[input_text, output_text]
     )
 
-app.launch()
+# Launch with debug mode
+if __name__ == "__main__":
+    print("🚀 Starting Forensic Analyzer...")
+    try:
+        # Test API connection
+        test_prompt = "Hello, world!"
+        test_result = crew.analyze_text(test_prompt)
+        print(f"Test analysis result: {test_result[:100]}...")
+        
+        # Launch app
+        app.launch(server_port=7860, show_error=True)
+    except Exception as e:
+        print(f"❌ Failed to launch: {str(e)}")