Update app.py

app.py

@@ -2,8 +2,6 @@ import gradio as gr
 import os
 from typing import Dict, List, Tuple
 import time
-import requests
-import json
 
 class GlossaryGenerator:
     def __init__(self):
@@ -40,9 +38,6 @@ Use this template to create individual glossary pages for specific terms. Fill i
 * **Content:**
    * List URLs, book titles, or other references.
 """
-        # Track request timing to avoid rate limits
-        self.last_request_time = 0
-        self.min_request_interval = 2.0  # Minimum 2 seconds between requests
 
     def _test_api_key(self, api_key: str) -> bool:
         """Test OpenAI API key with minimal request"""
@@ -50,37 +45,34 @@ Use this template to create individual glossary pages for specific terms. Fill i
             return False
         
         try:
-            # Test with minimal request using GPT-3.5-turbo (cheaper and more reliable)
-            test_result = self._call_openai_safe(api_key.strip(), "Hi", "gpt-3.5-turbo", 1)
-            return not test_result.startswith("❌")
+            # Import here to avoid import-time issues
+            from openai import OpenAI
+            
+            client = OpenAI(api_key=api_key.strip())
+            
+            # Test with minimal request
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[{"role": "user", "content": "Hi"}],
+                max_tokens=1
+            )
+            return True
             
         except Exception as e:
             print(f"API test error: {e}")
             return False
 
-    def _wait_for_rate_limit(self):
-        """Ensure minimum time between requests"""
-        current_time = time.time()
-        time_since_last = current_time - self.last_request_time
-        
-        if time_since_last < self.min_request_interval:
-            sleep_time = self.min_request_interval - time_since_last
-            print(f"⏰ Waiting {sleep_time:.1f}s to respect rate limits...")
-            time.sleep(sleep_time)
-        
-        self.last_request_time = time.time()
-
-    def _call_openai_safe(self, api_key: str, prompt: str, model: str = "gpt-3.5-turbo", max_tokens: int = 2000, max_retries: int = 2) -> str:
-        """Safe OpenAI API call with proper rate limiting and error handling"""
+    def _call_openai_raw(self, api_key: str, prompt: str, model: str = "gpt-4", max_tokens: int = 2000) -> str:
+        """Direct OpenAI API call using requests"""
+        import requests
+        import json
         
         if not api_key or not api_key.strip():
             return "🔑 Please enter your OpenAI API key above to generate content."
         
         clean_key = api_key.strip()
         
-        # Wait to respect rate limits
-        self._wait_for_rate_limit()
-        
+        # Direct API call to avoid client issues
         url = "https://api.openai.com/v1/chat/completions"
         headers = {
             "Authorization": f"Bearer {clean_key}",
@@ -100,112 +92,50 @@ Use this template to create individual glossary pages for specific terms. Fill i
             "presence_penalty": 0
         }
         
-        for attempt in range(max_retries):
-            try:
-                print(f"🚀 Making API call to {model} (attempt {attempt + 1}/{max_retries})")
-                
-                response = requests.post(url, headers=headers, json=data, timeout=60)
-                print(f"📊 Response status: {response.status_code}")
+        try:
+            print(f"🚀 Making direct API call to OpenAI...")
+            response = requests.post(url, headers=headers, json=data, timeout=60)
+            print(f"📊 Response status: {response.status_code}")
+            
+            if response.status_code == 200:
+                result = response.json()
+                content = result['choices'][0]['message']['content'].strip()
+                print("✅ API call successful")
+                return content
+            
+            else:
+                error_data = response.json() if response.content else {}
+                error_msg = error_data.get('error', {}).get('message', 'Unknown error')
+                error_code = error_data.get('error', {}).get('code', 'unknown')
                 
-                if response.status_code == 200:
-                    result = response.json()
-                    content = result['choices'][0]['message']['content'].strip()
-                    print("✅ API call successful")
-                    return content
+                print(f"❌ API call failed: {response.status_code} - {error_msg}")
                 
-                elif response.status_code == 401:
+                if response.status_code == 401:
                     return "❌ Invalid API key. Please check your OpenAI API key."
-                
                 elif response.status_code == 429:
-                    # Rate limit hit - get retry time from headers
-                    try:
-                        error_data = response.json()
-                        error_msg = error_data.get('error', {}).get('message', 'Rate limit exceeded')
-                    except:
-                        error_msg = "Rate limit exceeded"
-                    
-                    print(f"⏳ Rate limit hit: {error_msg}")
-                    
-                    # Get retry-after from headers or use exponential backoff
-                    retry_after = response.headers.get('retry-after')
-                    if retry_after:
-                        wait_time = min(int(retry_after), 60)  # Cap at 60 seconds
-                    else:
-                        wait_time = min((2 ** attempt) * 3, 30)  # Exponential backoff, capped at 30s
-                    
-                    if attempt < max_retries - 1:
-                        print(f"⏰ Waiting {wait_time} seconds before retry...")
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        return f"❌ Rate limit exceeded. Please wait a few minutes and try again. (Try using a different model or reducing request frequency)"
-                
-                elif response.status_code == 404:
-                    return f"❌ Model '{model}' not available. Try using 'gpt-3.5-turbo' or 'gpt-4o-mini' instead."
-                
-                elif response.status_code == 403:
-                    try:
-                        error_data = response.json()
-                        error_msg = error_data.get('error', {}).get('message', 'Access denied')
-                        if "insufficient_quota" in error_msg.lower():
-                            return "❌ OpenAI API quota exceeded. Please check your billing at https://platform.openai.com/usage"
-                        else:
-                            return f"❌ Access denied: {error_msg}"
-                    except:
-                        return "❌ Access denied. Check your API key permissions."
-                
-                else:
-                    # Other errors
-                    try:
-                        error_data = response.json()
-                        error_msg = error_data.get('error', {}).get('message', f'HTTP {response.status_code}')
-                    except:
-                        error_msg = f"HTTP {response.status_code}"
-                    
-                    print(f"❌ API Error: {error_msg}")
-                    
-                    if attempt < max_retries - 1:
-                        print(f"⏰ Waiting 3 seconds before retry...")
-                        time.sleep(3)
-                        continue
-                    else:
-                        return f"❌ API Error: {error_msg}"
-                        
-            except requests.exceptions.Timeout:
-                print(f"⏰ Request timeout on attempt {attempt + 1}")
-                if attempt < max_retries - 1:
-                    time.sleep(5)
-                    continue
+                    return "❌ Rate limit exceeded. Please wait a moment and try again."
+                elif response.status_code == 404 and model == "gpt-4":
+                    # Try GPT-3.5 fallback
+                    print("🔄 Trying GPT-3.5-turbo fallback...")
+                    return self._call_openai_raw(api_key, prompt, "gpt-3.5-turbo", max_tokens)
+                elif "insufficient_quota" in error_msg.lower():
+                    return "❌ OpenAI API quota exceeded. Please check your billing at https://platform.openai.com/usage"
                 else:
-                    return "❌ Request timeout. Please try again."
+                    return f"❌ OpenAI API Error ({response.status_code}): {error_msg}"
                     
-            except requests.exceptions.ConnectionError:
-                print(f"🌐 Connection error on attempt {attempt + 1}")
-                if attempt < max_retries - 1:
-                    time.sleep(3)
-                    continue
-                else:
-                    return "❌ Connection error. Please check your internet connection."
-                    
-            except Exception as e:
-                print(f"❌ Unexpected error on attempt {attempt + 1}: {str(e)}")
-                if attempt < max_retries - 1:
-                    time.sleep(2)
-                    continue
-                else:
-                    return f"❌ Unexpected error: {str(e)}"
-        
-        return "❌ All retry attempts failed. Please try again later."
+        except requests.exceptions.Timeout:
+            return "❌ Request timeout. Please try again."
+        except requests.exceptions.RequestException as e:
+            return f"❌ Network error: {str(e)}"
+        except Exception as e:
+            return f"❌ Unexpected error: {str(e)}"
 
-    def generate_new_content(self, api_key: str, term: str, context: str = "", target_audience: str = "general", preferred_model: str = "gpt-3.5-turbo") -> str:
+    def generate_new_content(self, api_key: str, term: str, context: str = "", target_audience: str = "general") -> str:
         """Generate new glossary content for a given term"""
         
         if not term.strip():
             return "Please enter a term to generate content for."
         
-        # Choose appropriate max_tokens based on model
-        max_tokens = 2500 if "gpt-4" in preferred_model else 2000
-        
         prompt = f"""
 Create a comprehensive glossary entry for the term "{term}" following this EXACT template structure:
 {self.template}
@@ -229,17 +159,14 @@ Create a comprehensive glossary entry for the term "{term}" following this EXACT
 Generate the complete glossary entry now:
 """
         
-        return self._call_openai_safe(api_key, prompt, preferred_model, max_tokens)
+        return self._call_openai_raw(api_key, prompt, max_tokens=2500)
 
-    def update_existing_content(self, api_key: str, term: str, existing_content: str, update_instructions: str = "", preferred_model: str = "gpt-3.5-turbo") -> Tuple[str, str]:
+    def update_existing_content(self, api_key: str, term: str, existing_content: str, update_instructions: str = "") -> Tuple[str, str]:
         """Analyze existing content and provide update recommendations"""
         
         if not term.strip() or not existing_content.strip():
             return "Please provide both term and existing content.", ""
         
-        # Choose appropriate max_tokens based on model
-        max_tokens = 1500 if "gpt-4" in preferred_model else 1200
-        
         # First, analyze the content
         analysis_prompt = f"""
 Analyze this existing glossary content for "{term}" against the template standard and provide specific improvement recommendations.
@@ -274,14 +201,7 @@ Analyze this existing glossary content for "{term}" against the template standar
 Format as a professional content analysis report.
 """
         
-        recommendations = self._call_openai_safe(api_key, analysis_prompt, preferred_model, max_tokens)
-        
-        if recommendations.startswith("❌"):
-            return recommendations, ""
-        
-        # Add extra wait time between the two requests
-        print("⏰ Waiting between analysis and content generation...")
-        time.sleep(3)
+        recommendations = self._call_openai_raw(api_key, analysis_prompt, max_tokens=1500)
         
         # Then generate updated content
         update_prompt = f"""
@@ -304,19 +224,16 @@ Create an improved version of the glossary entry for "{term}" based on the analy
 Generate the complete, improved glossary entry:
 """
         
-        updated_content = self._call_openai_safe(api_key, update_prompt, preferred_model, max_tokens + 500)
+        updated_content = self._call_openai_raw(api_key, update_prompt, max_tokens=2500)
         
         return recommendations, updated_content
 
-    def create_outline_brief(self, api_key: str, topic: str, scope: str = "comprehensive", preferred_model: str = "gpt-3.5-turbo") -> str:
+    def create_outline_brief(self, api_key: str, topic: str, scope: str = "comprehensive") -> str:
         """Create an outline or brief for new glossary content"""
         
         if not topic.strip():
             return "Please enter a topic for the outline."
         
-        # Choose appropriate max_tokens based on model
-        max_tokens = 3000 if "gpt-4" in preferred_model else 2500
-        
         prompt = f"""
 Create a comprehensive content brief for developing a glossary focused on "{topic}".
 **Scope:** {scope}
@@ -363,7 +280,7 @@ Create a comprehensive content brief for developing a glossary focused on "{topi
 Create a comprehensive, actionable brief that will guide the entire glossary development process.
 """
         
-        return self._call_openai_safe(api_key, prompt, preferred_model, max_tokens)
+        return self._call_openai_raw(api_key, prompt, max_tokens=3000)
 
 def create_gradio_interface():
     """Create the Gradio interface for the glossary generator"""
@@ -383,37 +300,38 @@ def create_gradio_interface():
         if len(clean_key) < 20:
             return "❌ API key too short - check if you copied the full key"
         
-        # Test the key
-        if generator._test_api_key(clean_key):
-            return "✅ API key is valid and connected!"
+        # Test the key with direct API call
+        test_result = generator._call_openai_raw(clean_key, "Test", "gpt-3.5-turbo", 1)
+        
+        if "❌" in test_result:
+            return test_result
         else:
-            return "❌ API key test failed - check your key and try again"
+            return "✅ API key is valid and connected!"
     
-    def generate_new_wrapper(api_key, term, context, audience, model):
+    def generate_new_wrapper(api_key, term, context, audience):
         if not term.strip():
             return "Please enter a term to generate content for."
-        return generator.generate_new_content(api_key, term, context, audience, model)
+        return generator.generate_new_content(api_key, term, context, audience)
     
-    def update_existing_wrapper(api_key, term, existing_content, update_instructions, model):
+    def update_existing_wrapper(api_key, term, existing_content, update_instructions):
         if not term.strip() or not existing_content.strip():
             return "Please provide both term and existing content.", ""
-        recommendations, updated_content = generator.update_existing_content(api_key, term, existing_content, update_instructions, model)
+        recommendations, updated_content = generator.update_existing_content(api_key, term, existing_content, update_instructions)
         return recommendations, updated_content
     
-    def create_outline_wrapper(api_key, topic, scope, model):
+    def create_outline_wrapper(api_key, topic, scope):
         if not topic.strip():
             return "Please enter a topic for the outline."
-        return generator.create_outline_brief(api_key, topic, scope, model)
+        return generator.create_outline_brief(api_key, topic, scope)
     
     # Create the Gradio interface
     with gr.Blocks(title="Glossary Content Generator", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
-        # 📚 Glossary Content Generator (Rate-Limit Safe)
+        # 📚 Glossary Content Generator
         
-        **Powered by OpenAI** - Professional glossary content creation and optimization tool.
+        **Powered by OpenAI GPT-4** - Professional glossary content creation and optimization tool.
         
         🔑 **Enter your OpenAI API key below to get started!**
-        ✅ **Now with improved rate limiting and error handling**
         """)
         
         # API Key Section
@@ -458,7 +376,7 @@ def create_gradio_interface():
         with gr.Tabs():
             # Tab 1: Generate New Content
             with gr.TabItem("🆕 Generate New Content"):
-                gr.Markdown("### Create a new glossary entry from scratch")
+                gr.Markdown("### Create a new glossary entry from scratch using GPT-4")
                 
                 with gr.Row():
                     with gr.Column(scale=1):
@@ -477,12 +395,6 @@ def create_gradio_interface():
                             choices=["general", "technical", "business", "beginner", "expert"],
                             value="general"
                         )
-                        new_model = gr.Dropdown(
-                            label="AI Model",
-                            choices=["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4", "gpt-4-turbo"],
-                            value="gpt-3.5-turbo",
-                            info="gpt-3.5-turbo is recommended for speed and cost"
-                        )
                         generate_btn = gr.Button("🚀 Generate Content", variant="primary", size="lg")
                     
                     with gr.Column(scale=2):
@@ -495,7 +407,7 @@ def create_gradio_interface():
                 
                 generate_btn.click(
                     generate_new_wrapper,
-                    inputs=[api_key_input, new_term, new_context, new_audience, new_model],
+                    inputs=[api_key_input, new_term, new_context, new_audience],
                     outputs=[new_output]
                 )
                 
@@ -504,7 +416,7 @@ def create_gradio_interface():
             
             # Tab 2: Update Existing Content
             with gr.TabItem("🔄 Update Existing Content"):
-                gr.Markdown("### Analyze and improve existing glossary entries")
+                gr.Markdown("### Analyze and improve existing glossary entries with AI-powered recommendations")
                 
                 with gr.Row():
                     with gr.Column(scale=1):
@@ -523,12 +435,6 @@ def create_gradio_interface():
                             placeholder="e.g., 'Add more technical details', 'Include recent developments', 'Improve SEO focus'",
                             lines=3
                         )
-                        update_model = gr.Dropdown(
-                            label="AI Model",
-                            choices=["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4", "gpt-4-turbo"],
-                            value="gpt-3.5-turbo",
-                            info="Note: This makes 2 API calls (analysis + update)"
-                        )
                         update_btn = gr.Button("🔍 Analyze & Update", variant="primary", size="lg")
                     
                     with gr.Column(scale=2):
@@ -549,7 +455,7 @@ def create_gradio_interface():
                 
                 update_btn.click(
                     update_existing_wrapper,
-                    inputs=[api_key_input, update_term, existing_content, update_instructions, update_model],
+                    inputs=[api_key_input, update_term, existing_content, update_instructions],
                     outputs=[recommendations_output, updated_content_output]
                 )
             
@@ -569,12 +475,6 @@ def create_gradio_interface():
                             choices=["comprehensive", "focused", "basic", "advanced", "specialized"],
                             value="comprehensive"
                         )
-                        outline_model = gr.Dropdown(
-                            label="AI Model",
-                            choices=["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4", "gpt-4-turbo"],
-                            value="gpt-3.5-turbo",
-                            info="Larger briefs may benefit from GPT-4"
-                        )
                         outline_btn = gr.Button("📋 Create Strategic Brief", variant="primary", size="lg")
                     
                     with gr.Column(scale=2):
@@ -587,7 +487,7 @@ def create_gradio_interface():
                 
                 outline_btn.click(
                     create_outline_wrapper,
-                    inputs=[api_key_input, outline_topic, outline_scope, outline_model],
+                    inputs=[api_key_input, outline_topic, outline_scope],
                     outputs=[outline_output]
                 )
                 
@@ -616,22 +516,19 @@ def create_gradio_interface():
         5. **Copy and paste** it into the field above
         
         ## 💰 **Cost Information:**
-        - **GPT-3.5-turbo**: ~$0.0015 per 1K input tokens, ~$0.002 per 1K output tokens (Recommended)
-        - **GPT-4**: ~$0.03 per 1K input tokens, ~$0.06 per 1K output tokens
-        - **Per generation**: $0.003-0.10 depending on model and content length
-        
-        ## ✨ **New Features & Fixes:**
-        - 🛡️ **Rate Limit Protection**: 2-second delays between requests
-        - 🔄 **Smart Retry Logic**: Exponential backoff on rate limits
-        - 🚫 **No More Double Requests**: Removed automatic model fallbacks
-        - ⚡ **Model Selection**: Choose your preferred AI model
-        - 📊 **Better Error Messages**: Clear feedback on what went wrong
-        - 🎯 **GPT-3.5 Default**: Faster, cheaper, and more reliable for most tasks
-        
-        ## 📊 **Model Recommendations:**
-        - **GPT-3.5-turbo**: Best for most glossary content (fast, cheap, high quality)
-        - **GPT-4o-mini**: Good balance of quality and cost
-        - **GPT-4**: Use for complex technical content or when highest quality needed
+        - **GPT-4 pricing**: ~$0.03 per 1K input tokens, ~$0.06 per 1K output tokens
+        - **Per generation**: Approximately $0.02-0.10 depending on content length
+        - **Very cost-effective** for professional content creation
+        
+        ## ✨ **Features:**
+        - 🤖 **GPT-4 Powered**: High-quality, professional content generation
+        - 📝 **Template Consistency**: Follows your exact 6-section structure
+        - 🔍 **Content Analysis**: Detailed improvement recommendations
+        - 📊 **Strategic Planning**: Comprehensive content briefs and roadmaps
+        - 🎯 **SEO Optimized**: Includes PAA questions and keyword strategies
+        - 📋 **Copy-Friendly**: Easy copy buttons for all outputs
+        - 🔑 **No Setup Required**: Just enter your API key and start generating!
+        - 🛠️ **Direct API**: Uses raw HTTP requests to avoid library conflicts
         """)
     
     return demo