Update src/app.py

src/app.py

@@ -61,46 +61,101 @@ from reportlab.lib.units import inch
 
 # Claude Chatbot Class
 import time
+import os
+import requests
+import json
+import streamlit as st
 
 class ClaudeChatbot:
     def __init__(self):
         self.api_key = os.getenv('OPENROUTER_API_KEY')
         self.base_url = "https://openrouter.ai/api/v1/chat/completions"
         
-        # Use a single reliable free model
+        # Use a reliable free model
         self.model = "meta-llama/llama-3.2-3b-instruct:free"
         
-        # Rate limiting variables
+        # More lenient rate limiting
         self.last_request_time = 0
-        self.min_request_interval = 6  # 6 seconds between requests for OpenRouter free tier
+        self.min_request_interval = 2  # Reduced to 2 seconds
         self.daily_requests = 0
-        self.max_daily_requests = 50  # OpenRouter free tier limit
+        self.max_daily_requests = 200  # Increased limit
+        
+        # Debug mode
+        self.debug = True
         
         if not self.api_key:
             st.error("❌ OPENROUTER_API_KEY not found in environment variables!")
             st.info("Please set your OpenRouter API key in the environment variables.")
+            if self.debug:
+                st.write("**Debug**: Checked environment variable 'OPENROUTER_API_KEY'")
     
     def _wait_for_rate_limit(self):
-        """Ensure we don't exceed rate limits - OpenRouter free tier requires 5+ second intervals"""
+        """Ensure we don't exceed rate limits"""
         current_time = time.time()
         time_since_last_request = current_time - self.last_request_time
         
-        # OpenRouter free tier requires 5+ seconds between requests
         if time_since_last_request < self.min_request_interval:
             sleep_time = self.min_request_interval - time_since_last_request
-            st.info(f"Rate limiting: waiting {sleep_time:.1f} seconds...")
+            if self.debug:
+                st.info(f"Rate limiting: waiting {sleep_time:.1f} seconds...")
             time.sleep(sleep_time)
         
         self.last_request_time = time.time()
     
+    def test_connection(self):
+        """Test the API connection with a simple request"""
+        if not self.api_key:
+            return "Error: No API key found"
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://streamlit-resume-analyzer.com",
+            "X-Title": "AI Resume Analyzer"
+        }
+        
+        test_data = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Say 'Connection test successful'"}
+            ],
+            "max_tokens": 50,
+            "temperature": 0.1
+        }
+        
+        try:
+            response = requests.post(self.base_url, headers=headers, json=test_data, timeout=10)
+            
+            if self.debug:
+                st.write(f"**Debug - Test Response Status**: {response.status_code}")
+                st.write(f"**Debug - Response Headers**: {dict(response.headers)}")
+            
+            if response.status_code == 200:
+                result = response.json()
+                if 'choices' in result and len(result['choices']) > 0:
+                    return f"✅ Connection successful: {result['choices'][0]['message']['content']}"
+                else:
+                    return f"❌ Unexpected response format: {result}"
+            else:
+                error_text = response.text
+                return f"❌ Connection failed ({response.status_code}): {error_text}"
+                
+        except requests.exceptions.Timeout:
+            return "❌ Connection test timed out"
+        except requests.exceptions.ConnectionError:
+            return "❌ Connection error - check internet connection"
+        except Exception as e:
+            return f"❌ Test failed: {str(e)}"
+    
     def generate_response(self, prompt, context="", max_tokens=1000):
-        """Generate response using the configured model with rate limiting"""
+        """Generate response with improved error handling and debugging"""
         if not self.api_key:
             return "Error: API key not configured. Please set OPENROUTER_API_KEY in your environment variables."
         
         # Check daily limit
         if self.daily_requests >= self.max_daily_requests:
-            return f"Daily request limit reached ({self.max_daily_requests} requests). Please try again tomorrow or add credits to your OpenRouter account."
+            return f"Daily request limit reached ({self.max_daily_requests} requests). Please try again tomorrow."
         
         # Rate limiting
         self._wait_for_rate_limit()
@@ -116,7 +171,7 @@ class ClaudeChatbot:
         
         if context:
             # Limit context to avoid token limits
-            system_prompt += f"\n\nContext about the user's resume:\n{context[:1500]}"
+            system_prompt += f"\n\nContext about the user's resume:\n{context[:1000]}"
         
         data = {
             "model": self.model,
@@ -130,40 +185,71 @@ class ClaudeChatbot:
             "frequency_penalty": 0.1
         }
         
+        if self.debug:
+            st.write(f"**Debug - Request URL**: {self.base_url}")
+            st.write(f"**Debug - Model**: {self.model}")
+            st.write(f"**Debug - Prompt length**: {len(prompt)} chars")
+            st.write(f"**Debug - Context length**: {len(context)} chars")
+        
         try:
-            st.info(f"Making API request... (Daily requests used: {self.daily_requests}/{self.max_daily_requests})")
+            if self.debug:
+                st.info(f"Making API request... (Daily requests used: {self.daily_requests}/{self.max_daily_requests})")
+            
             response = requests.post(self.base_url, headers=headers, json=data, timeout=30)
             
-            # Log response status for debugging
-            st.info(f"API Response Status: {response.status_code}")
+            if self.debug:
+                st.write(f"**Debug - Response Status**: {response.status_code}")
+                st.write(f"**Debug - Response Headers**: {dict(response.headers)}")
             
-            # Handle different error codes
+            # Handle different error codes with more detail
             if response.status_code == 429:
-                error_data = response.json() if response.headers.get('content-type') == 'application/json' else {}
-                return f"Rate limit exceeded. Error details: {error_data.get('error', {}).get('message', 'Unknown rate limit error')}"
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get('error', {}).get('message', 'Rate limit exceeded')
+                    return f"Rate limit exceeded: {error_message}. Please wait and try again."
+                except:
+                    return "Rate limit exceeded. Please wait a few minutes and try again."
+                    
             elif response.status_code == 402:
-                return "This model requires payment. Please add credits to your OpenRouter account or wait for the daily limit to reset."
+                return "This request requires payment. Please add credits to your OpenRouter account."
+                
             elif response.status_code == 401:
                 return "Invalid API key. Please check your OPENROUTER_API_KEY environment variable."
+                
             elif response.status_code == 400:
-                error_data = response.json() if response.headers.get('content-type') == 'application/json' else {}
-                return f"Bad request. Error: {error_data.get('error', {}).get('message', 'Invalid request format')}"
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get('error', {}).get('message', 'Bad request')
+                    if self.debug:
+                        st.write(f"**Debug - 400 Error Details**: {error_data}")
+                    return f"Bad request: {error_message}"
+                except:
+                    return f"Bad request. Raw response: {response.text[:200]}"
+                    
             elif response.status_code != 200:
                 try:
                     error_data = response.json()
-                    return f"API Error {response.status_code}: {error_data.get('error', {}).get('message', response.text[:200])}"
+                    error_message = error_data.get('error', {}).get('message', response.text[:200])
+                    return f"API Error {response.status_code}: {error_message}"
                 except:
                     return f"API Error {response.status_code}: {response.text[:200]}"
             
-            result = response.json()
-            
-            if 'choices' in result and len(result['choices']) > 0:
-                self.daily_requests += 1  # Increment only on successful response
-                response_text = result['choices'][0]['message']['content'].strip()
-                st.success(f"Response generated successfully! (Remaining daily requests: {self.max_daily_requests - self.daily_requests})")
-                return response_text
-            else:
-                return f"Error: Unexpected response format. Response: {json.dumps(result, indent=2)[:500]}"
+            # Success case
+            try:
+                result = response.json()
+                if self.debug:
+                    st.write(f"**Debug - Response keys**: {list(result.keys())}")
+                
+                if 'choices' in result and len(result['choices']) > 0:
+                    self.daily_requests += 1
+                    response_text = result['choices'][0]['message']['content'].strip()
+                    if self.debug:
+                        st.success(f"Response generated successfully! (Remaining: {self.max_daily_requests - self.daily_requests})")
+                    return response_text
+                else:
+                    return f"Error: Unexpected response format. Response keys: {list(result.keys())}"
+            except json.JSONDecodeError as e:
+                return f"Error: Invalid JSON response. Raw response: {response.text[:200]}"
                 
         except requests.exceptions.Timeout:
             return "Request timed out after 30 seconds. Please try again with a shorter question."
@@ -171,12 +257,9 @@ class ClaudeChatbot:
             return "Connection error. Please check your internet connection and try again."
         except requests.exceptions.RequestException as e:
             return f"Request error: {str(e)}"
-        except json.JSONDecodeError as e:
-            return f"Error: Invalid JSON response from API. Raw response: {response.text[:200]}"
         except Exception as e:
             return f"Unexpected error: {str(e)}"
 
-
 # Download NLTK data if not already present
 @st.cache_resource
 def download_nltk_data():