Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import json
 import os
 import time
+import requests
 from openai import OpenAI
 
 class DeepDreamInterpreter:
@@ -17,28 +18,74 @@ class DeepDreamInterpreter:
             return "Please provide a valid API key."
             
         try:
-            self.api_key = api_key
+            self.api_key = api_key.strip()
             self.client = OpenAI(
                 base_url="https://openrouter.ai/api/v1",
-                api_key=api_key,
+                api_key=self.api_key,
             )
-            # Test the API key with a simple request
-            test_response = self.client.chat.completions.create(
-                extra_headers={
-                    "HTTP-Referer": "https://deepdreaminterpreter.com",
-                    "X-Title": "Deep Dream Interpreter",
-                },
-                model="google/gemini-2.5-flash-preview:thinking",
-                messages=[
-                    {"role": "user", "content": "Hello, this is a test."}
-                ],
-                max_tokens=5  # Keep it minimal for the test
-            )
-            return "API key configured successfully!"
+            return "API key configured successfully! You can now analyze dreams."
         except Exception as e:
             self.client = None
             self.api_key = None
             return f"API configuration failed: {str(e)}"
+    
+    def _make_api_call(self, messages, model="google/gemini-2.5-flash-preview:thinking"):
+        """Make an API call to OpenRouter with proper error handling"""
+        if not self.client:
+            raise ValueError("API client not configured")
+            
+        try:
+            # Direct API call using requests for more control
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://deepdreaminterpreter.com",
+                "X-Title": "Deep Dream Interpreter"
+            }
+            
+            payload = {
+                "model": model,
+                "messages": messages
+            }
+            
+            response = requests.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers=headers,
+                json=payload
+            )
+            
+            # Check if response is successful
+            if response.status_code != 200:
+                error_msg = f"API Error (Status {response.status_code}): "
+                try:
+                    error_data = response.json()
+                    error_msg += error_data.get('error', {}).get('message', 'Unknown error')
+                except:
+                    error_msg += response.text[:100] + "..."
+                
+                print(f"API error: {error_msg}")
+                raise ValueError(error_msg)
+            
+            # Parse the response
+            data = response.json()
+            
+            # Validate response structure
+            if 'choices' not in data or not data['choices'] or 'message' not in data['choices'][0]:
+                raise ValueError("Invalid response structure from API")
+                
+            # Extract the content
+            content = data['choices'][0]['message'].get('content', '')
+            if not content:
+                raise ValueError("Empty content in API response")
+                
+            return content
+            
+        except requests.exceptions.RequestException as e:
+            raise ValueError(f"Network error: {str(e)}")
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON response from API")
+        except Exception as e:
+            raise ValueError(f"Error in API call: {str(e)}")
         
     def analyze_dream(self, dream_description, include_visualization=True, user_name="Anonymous"):
         """Analyze the provided dream description using Gemini 2.5 Flash"""
@@ -47,107 +94,104 @@ class DeepDreamInterpreter:
             
         if not dream_description or not dream_description.strip():
             return "Please enter a dream description to analyze."
+        
+        # Clean input
+        dream_description = dream_description.strip()
+        if user_name:
+            user_name = user_name.strip()
+        else:
+            user_name = "Anonymous"
             
         try:
             # First pass: Dream analysis with thinking capabilities
             print("Starting dream analysis...")
             
             # System prompt for dream analysis
-            system_prompt = """You are an expert dream analyst. Analyze the following dream description, identifying key symbols, emotions, themes, and potential psychological meanings. 
-            Structure your analysis in these sections: 
-            - Summary
-            - Key Symbols
-            - Emotional Landscape
-            - Themes
-            - Psychological Interpretation
-            
-            Be thoughtful, nuanced, and avoid overgeneralizations."""
-            
-            analysis_response = self.client.chat.completions.create(
-                extra_headers={
-                    "HTTP-Referer": "https://deepdreaminterpreter.com",
-                    "X-Title": "Deep Dream Interpreter",
+            analysis_messages = [
+                {
+                    "role": "system",
+                    "content": """You are an expert dream analyst. Analyze the following dream description, identifying key symbols, emotions, themes, and potential psychological meanings. 
+                    Structure your analysis in these sections: 
+                    - Summary
+                    - Key Symbols
+                    - Emotional Landscape
+                    - Themes
+                    - Psychological Interpretation
+                    
+                    Be thoughtful, nuanced, and avoid overgeneralizations."""
                 },
-                model="google/gemini-2.5-flash-preview:thinking",
-                messages=[
-                    {
-                        "role": "system",
-                        "content": system_prompt
-                    },
-                    {
-                        "role": "user",
-                        "content": f"Dream description from user {user_name}: {dream_description}"
-                    }
-                ]
-            )
+                {
+                    "role": "user",
+                    "content": f"Dream description from user {user_name}: {dream_description}"
+                }
+            ]
             
-            # Check if we got a valid response
-            if not analysis_response or not hasattr(analysis_response, 'choices') or not analysis_response.choices:
-                return "Error: Received an invalid response from the API during analysis."
-                
-            dream_analysis = analysis_response.choices[0].message.content
+            # Make API call for dream analysis
+            try:
+                dream_analysis = self._make_api_call(analysis_messages)
+            except ValueError as e:
+                return f"Dream analysis failed: {str(e)}\n\nPlease check your API key and try again."
             
             # If visualization is not needed, return just the analysis
             if not include_visualization:
-                return dream_analysis
+                return f"""## Dream Analysis
+
+{dream_analysis}"""
                 
             # Second pass: Visual interpretation
             print("Generating visualization prompt...")
             
-            # System prompt for visualization
-            visualization_system_prompt = """Based on this dream analysis, create a detailed visual description that could be used as a prompt for an image generation model. 
-            Make it evocative and detailed, including:
-            - Colors and lighting
-            - Atmosphere and mood
-            - Composition and perspective
-            - Key elements and their arrangement
-            - Symbolic representations
-            
-            Create something that captures the essence and emotional quality of the dream."""
-            
-            visualization_response = self.client.chat.completions.create(
-                extra_headers={
-                    "HTTP-Referer": "https://deepdreaminterpreter.com",
-                    "X-Title": "Deep Dream Interpreter",
+            visualization_messages = [
+                {
+                    "role": "system",
+                    "content": """Based on this dream analysis, create a detailed visual description that could be used as a prompt for an image generation model. 
+                    Make it evocative and detailed, including:
+                    - Colors and lighting
+                    - Atmosphere and mood
+                    - Composition and perspective
+                    - Key elements and their arrangement
+                    - Symbolic representations
+                    
+                    Create something that captures the essence and emotional quality of the dream."""
                 },
-                model="google/gemini-2.5-flash-preview:thinking",
-                messages=[
-                    {
-                        "role": "system",
-                        "content": visualization_system_prompt
-                    },
-                    {
-                        "role": "user",
-                        "content": f"Dream analysis: {dream_analysis}"
-                    }
-                ]
-            )
+                {
+                    "role": "user",
+                    "content": f"Dream analysis: {dream_analysis}"
+                }
+            ]
             
-            # Check if we got a valid response
-            if not visualization_response or not hasattr(visualization_response, 'choices') or not visualization_response.choices:
-                # If visualization fails, still return the analysis
-                return f"""## Dream Analysis
+            # Make API call for visualization
+            try:
+                visualization_prompt = self._make_api_call(visualization_messages)
+                
+                # Combine the results
+                full_response = f"""## Dream Analysis
 
 {dream_analysis}
 
 ## Visualization Prompt
 
-Error: Unable to generate visualization prompt. Please try again later.
+{visualization_prompt}
+
+---
+*Note: This visualization prompt can be used with image generation models like DALL-E, Midjourney, or Stable Diffusion to create a visual representation of your dream.*
 """
-            
-            # Combine the results
-            full_response = f"""## Dream Analysis
+                return full_response
+                
+            except ValueError as e:
+                # If visualization fails, still return the analysis
+                print(f"Visualization error: {str(e)}")
+                return f"""## Dream Analysis
 
 {dream_analysis}
 
 ## Visualization Prompt
 
-{visualization_response.choices[0].message.content}
+Error: Unable to generate visualization prompt. Please try again later.
 
 ---
-*Note: This visualization prompt can be used with image generation models like DALL-E, Midjourney, or Stable Diffusion to create a visual representation of your dream.*
+*Note: The dream analysis was successful, but we encountered an issue generating the visualization prompt.*
 """
-            return full_response
             
         except Exception as e:
             error_message = str(e)
@@ -159,13 +203,16 @@ Error: Unable to generate visualization prompt. Please try again later.
         try:
             if not user_name or not user_name.strip():
                 user_name = "Anonymous"
+            else:
+                user_name = user_name.strip()
                 
             # Create dreams directory if it doesn't exist
             os.makedirs("dreams", exist_ok=True)
                 
             # Create a filename based on user and timestamp
             timestamp = time.strftime("%Y%m%d-%H%M%S")
-            filename = f"dreams/{user_name.replace(' ', '_')}_{timestamp}.json"
+            safe_username = ''.join(c if c.isalnum() or c == '_' else '_' for c in user_name.replace(' ', '_'))
+            filename = f"dreams/{safe_username}_{timestamp}.json"
             
             # Create the dream data
             dream_data = {
@@ -198,23 +245,28 @@ def create_gradio_interface():
     
     # Define the process function for dream analysis
     def process_dream(api_key, dream_description, include_visualization, user_name):
+        # Show processing message
+        yield "Processing your dream... Please wait."
+        
         # If API key changed or not set up, configure it first
         if not interpreter.client or api_key.strip() != interpreter.api_key:
             setup_message = interpreter.setup_client(api_key)
             if "successfully" not in setup_message:
-                return setup_message
+                yield setup_message
+                return
         
         # Validate dream description
         if not dream_description or not dream_description.strip():
-            return "Please enter a dream description."
+            yield "Please enter a dream description."
+            return
         
         # Perform analysis
         analysis = interpreter.analyze_dream(dream_description, include_visualization, user_name)
-        return analysis
+        yield analysis
     
     # Define the save function
     def save_dream_entry(api_key, user_name, dream_description, analysis_output):
-        if not analysis_output or "Error" in analysis_output:
+        if not analysis_output or analysis_output == "Processing your dream... Please wait." or "Error" in analysis_output:
             return "Nothing to save or analysis contains errors."
         
         if not interpreter.client or api_key.strip() != interpreter.api_key:
@@ -284,6 +336,11 @@ def create_gradio_interface():
             3. Click "Analyze Dream"
             4. Optionally save your analysis
             
+            ### Troubleshooting:
+            - If you encounter an error, make sure your API key is valid and has access to the Gemini 2.5 Flash Preview model
+            - Check that your OpenRouter account has sufficient credits
+            - Try a shorter dream description if you're experiencing timeout issues
+            
             ### Requirements:
             - An OpenRouter API key with access to Google's Gemini 2.5 Flash Preview model
             """)