Update app.py

app.py

@@ -2,248 +2,115 @@ import gradio as gr
 import openai
 import os
 from dotenv import load_dotenv
-from typing import Dict, List
-import json
 
 # Load environment variables
 load_dotenv()
 
-# Initialize OpenAI
+# Initialize OpenAI (compatible with both old and new versions)
 try:
+    # Try new OpenAI client first
     from openai import OpenAI
     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY").strip())
     new_openai = True
 except ImportError:
+    # Fall back to old version
     openai.api_key = os.getenv("OPENAI_API_KEY").strip()
     new_openai = False
 
-class ForensicAgent:
-    """Base class for forensic analysis agents"""
-    def __init__(self, role: str, expertise: str):
-        self.role = role
-        self.expertise = expertise
+def analyze_text(text):
+    """Advanced forensic analysis with improved prompt and formatted output"""
     
-    def analyze(self, text: str) -> Dict:
-        """Perform analysis and return findings"""
-        raise NotImplementedError
-
-    def _get_analysis(self, prompt: str) -> Dict:
-        """Generic OpenAI request handler"""
-        try:
-            if new_openai:
-                response = client.chat.completions.create(
-                    model="gpt-4",
-                    messages=[
-                        {"role": "system", "content": f"You are {self.role}, {self.expertise}."},
-                        {"role": "user", "content": prompt}
-                    ],
-                    temperature=0.1,
-                    response_format={"type": "json_object"}
-                )
-                return json.loads(response.choices[0].message.content)
-            else:
-                response = openai.ChatCompletion.create(
-                    model="gpt-4",
-                    messages=[
-                        {"role": "system", "content": f"You are {self.role}, {self.expertise}."},
-                        {"role": "user", "content": prompt}
-                    ],
-                    temperature=0.1,
-                    response_format={"type": "json_object"}
-                )
-                return json.loads(response['choices'][0]['message']['content'])
-        except Exception as 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"""
-    def __init__(self):
-        super().__init__("Prof. Cognitus", "Cognitive Linguistics Specialist")
-    
-    def analyze(self, text: str) -> Dict:
-        prompt = f"""
-        Analyze this text for cognitive markers:
-        {text}
-        
-        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)
-
-class SemanticAgent(ForensicAgent):
-    """Analyzes semantic and contextual patterns"""
-    def __init__(self):
-        super().__init__("Dr. Semantica", "Semantic Forensics Expert")
-    
-    def analyze(self, text: str) -> Dict:
-        prompt = f"""
-        Analyze this text for semantic patterns:
-        {text}
-        
-        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)
-
-class ForensicCrew:
-    """Orchestrates multiple forensic agents"""
-    def __init__(self):
-        self.agents = [
-            StylometricAgent(),
-            CognitiveAgent(),
-            SemanticAgent()
-        ]
-    
-    def analyze_text(self, text: str) -> str:
-        """Coordinate multi-agent analysis"""
-        if len(text.strip()) < 30:
-            return "⚠️ Please provide at least 50 characters for accurate analysis."
-        
-        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:
-        """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": prompt}
-                    ],
-                    temperature=0.1,
-                    max_tokens=800
-                )
-                return response.choices[0].message.content
-            else:
-                response = openai.ChatCompletion.create(
-                    model="gpt-4",
-                    messages=[
-                        {"role": "system", "content": "You are Dr. Lexica, Chief Forensic Analyst."},
-                        {"role": "user", "content": prompt}
-                    ],
-                    temperature=0.1,
-                    max_tokens=800
-                )
-                return response['choices'][0]['message']['content']
-        except Exception as e:
-            return f"🔴 Report Generation Failed: {str(e)}"
-
-# Initialize the forensic crew
-crew = ForensicCrew()
-
-# Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as app:
-    gr.Markdown("""
-    # 🔬 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 (50+ characters recommended)..."
+    expert_prompt = f"""
+    [ROLE]
+    You are Dr. Lexica, a world-renowned forensic linguistics expert specializing in AI/human text differentiation with 25 years of experience.
+
+    [ANALYSIS TASK]
+    Perform a comprehensive forensic analysis on the following text to determine its origin with maximum accuracy:
+
+    [TEXT TO ANALYZE]
+    {text}
+
+    [ANALYSIS FRAMEWORK]
+    1. **Stylometric Analysis**:
+       - Sentence structure complexity (human: varied, AI: uniform)
+       - Lexical sophistication (human: contextual, AI: textbook-like)
+       - Punctuation patterns (human: emotional, AI: formulaic)
+
+    2. **Cognitive Fingerprinting**:
+       - Presence of hedges ("maybe", "I think") → human
+       - Overconfidence markers ("clearly", "undoubtedly") → AI
+       - Personal anecdotes → human
+       - Generic statements → AI
+
+    3. **Semantic Forensics**:
+       - Metaphor density (human: 3-5 per 100 words, AI: 0-2)
+       - Contextual anchoring (human: specific references, AI: vague)
+       - Error patterns (human: typos, AI: semantic inconsistencies)
+
+    4. **Temporal Markers**:
+       - References to time/age (human: specific dates, AI: generic)
+       - Cultural references (human: nuanced, AI: stereotypical)
+
+    [REQUIRED OUTPUT FORMAT]
+    # 🕵️‍♂️ Forensic Text Analysis Report
+
+    ## 🔍 Verdict
+    **Origin:** {{Human/AI/Inconclusive}}  
+    **Confidence Level:** {{XX%}}  
+    **Detection Score:** {{X/10}}
+
+    ## 📊 Key Indicators
+    🟢 **Human Markers Found:**  
+    - {{Marker 1}}  
+    - {{Marker 2}}  
+
+    🔴 **AI Markers Found:**  
+    - {{Marker 1}}  
+    - {{Marker 2}}  
+
+    ## 🧐 Detailed Findings
+    ### 1️⃣ Stylometric Evidence
+    - {{Analysis point 1}}  
+    - {{Analysis point 2}}  
+
+    ### 2️⃣ Cognitive Patterns
+    - {{Analysis point 1}}  
+    - {{Analysis point 2}}  
+
+    ### 3️⃣ Semantic Fingerprints
+    - {{Analysis point 1}}  
+    - {{Analysis point 2}}  
+
+    ## 💡 Expert Conclusion
+    {{3-4 sentence authoritative conclusion with final determination. Highlight any interesting nuances or exceptional cases.}}
+
+    ⚠️ **Disclaimer:** This analysis has {{confidence}}% accuracy based on current forensic linguistics models.
+    """
+
+    try:
+        if new_openai:
+            response = client.chat.completions.create(
+                model="gpt-4",  # Changed to GPT-4
+                messages=[
+                    {"role": "system", "content": "You are a forensic text analysis AI specializing in detecting AI-generated content with extreme precision."},
+                    {"role": "user", "content": expert_prompt}
+                ],
+                temperature=0.1,
+                max_tokens=500
             )
-            with gr.Row():
-                analyze_btn = gr.Button("🧪 Analyze Text", variant="primary")
-                clear_btn = gr.Button("🔄 Clear")
-        
-        with gr.Column():
-            output_text = gr.Markdown(
-                label="📜 Forensic Analysis Report",
-                elem_classes=["output-panel"]
+            return response.choices[0].message.content
+        else:
+            response = openai.ChatCompletion.create(
+                model="gpt-4",  # Changed to GPT-4
+                messages=[
+                    {"role": "system", "content": "You are a forensic text analysis AI specializing in detecting AI-generated content with extreme precision."},
+                    {"role": "user", "content": expert_prompt}
+                ],
+                temperature=0.1,
+                max_tokens=500
             )
-    
-    # Example texts
-    gr.Examples(
-        examples=[
-            ["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:"
-    )
-    
-    # Button actions
-    analyze_btn.click(
-        fn=crew.analyze_text,
-        inputs=input_text,
-        outputs=output_text,
-        api_name="analyze"
-    )
-    
-    clear_btn.click(
-        fn=lambda: ("", ""),
-        inputs=None,
-        outputs=[input_text, output_text]
-    )
-
-# 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)
+            return response['choices'][0]['message']['content']
     except Exception as e:
-        print(f"❌ Failed to launch: {str(e)}")
+        return f"🔴 Analysis failed. Error: {str(e)}"
+
+# Rest of your Gradio interface remains the same...