update app6

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 import os
-import hashlib
 import time
 from collections import defaultdict
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
@@ -11,20 +10,22 @@ HF_TOKEN = os.getenv("HF_TOKEN")
 API_KEY = os.getenv("API_KEY")
 ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD")
 
-print(f"🔐 Security Status:")
+print("🔐 Security Status:")
 print(f"   HF_TOKEN: {'✅ Set' if HF_TOKEN else '❌ Not set'}")
 print(f"   API_KEY: {'✅ Set' if API_KEY else '❌ Not set'}")
 print(f"   ADMIN_PASSWORD: {'✅ Set' if ADMIN_PASSWORD else '❌ Not set'}")
 
-# Rate limiting storage
+# Simple rate limiting
 request_counts = defaultdict(list)
 
-# Load model with optional HF token
+# Load model
 model_name = "gpt2"
+print("📦 Loading model...")
+
 try:
     if HF_TOKEN:
-        tokenizer = GPT2Tokenizer.from_pretrained(model_name, use_auth_token=HF_TOKEN)
-        model = GPT2LMHeadModel.from_pretrained(model_name, use_auth_token=HF_TOKEN)
+        tokenizer = GPT2Tokenizer.from_pretrained(model_name, token=HF_TOKEN)
+        model = GPT2LMHeadModel.from_pretrained(model_name, token=HF_TOKEN)
         print("✅ Model loaded with HF token")
     else:
         tokenizer = GPT2Tokenizer.from_pretrained(model_name)
@@ -32,240 +33,173 @@ try:
         print("✅ Model loaded without token")
         
     tokenizer.pad_token = tokenizer.eos_token
-    print("✅ Model initialization complete")
+    print("✅ Model ready!")
     
 except Exception as e:
     print(f"❌ Model loading failed: {e}")
-    raise e
+    raise
 
-def validate_api_key(provided_key):
-    """Validate API key with rate limiting"""
+def check_api_key(provided_key):
+    """Simple API key validation with rate limiting"""
     if not API_KEY:
-        return True, "No API key required"
-    
-    if not provided_key:
-        return False, "API key required but not provided"
+        return True, "Public access"
     
-    if provided_key != API_KEY:
-        return False, "Invalid API key"
+    if not provided_key or provided_key != API_KEY:
+        return False, "Invalid or missing API key"
     
-    # Rate limiting per API key
+    # Simple rate limiting (100 requests per hour)
     now = time.time()
-    key_hash = hashlib.sha256(provided_key.encode()).hexdigest()[:8]
+    hour_ago = now - 3600
     
-    # Clean old requests (last hour)
-    request_counts[key_hash] = [
-        req_time for req_time in request_counts[key_hash]
-        if now - req_time < 3600
+    # Clean old requests
+    request_counts[provided_key] = [
+        t for t in request_counts[provided_key] if t > hour_ago
     ]
     
-    # Check rate limit (100 requests per hour)
-    if len(request_counts[key_hash]) >= 100:
-        return False, "Rate limit exceeded (100 requests/hour)"
+    if len(request_counts[provided_key]) >= 100:
+        return False, "Rate limit exceeded (100/hour)"
     
-    # Log successful request
-    request_counts[key_hash].append(now)
-    return True, f"Authenticated (Requests: {len(request_counts[key_hash])}/100)"
+    request_counts[provided_key].append(now)
+    return True, f"Authenticated ({len(request_counts[provided_key])}/100)"
 
-def generate_text(prompt, max_length=100, temperature=0.7, top_p=0.9, top_k=50, api_key=""):
-    """Generate text with security validation"""
+def generate_text(prompt, max_length, temperature, top_p, top_k, api_key):
+    """Generate text with GPT-2"""
     
-    # Validate API key
-    is_valid, message = validate_api_key(api_key)
-    if not is_valid:
-        return f"🔒 Authentication Error: {message}"
+    # API key check
+    valid, msg = check_api_key(api_key)
+    if not valid:
+        return f"🔒 Error: {msg}"
     
-    # Input validation
-    if not prompt or len(prompt.strip()) == 0:
-        return "❌ Error: Prompt cannot be empty"
+    # Input validation  
+    if not prompt.strip():
+        return "❌ Please enter a prompt"
     
     if len(prompt) > 1000:
-        return "❌ Error: Prompt too long (max 1000 characters)"
+        return "❌ Prompt too long (max 1000 chars)"
     
     try:
-        print(f"🔑 {message}")
-        print(f"📝 Generating text for prompt: {prompt[:50]}...")
+        print(f"🔑 {msg}")
+        print(f"📝 Generating: {prompt[:50]}...")
         
-        inputs = tokenizer.encode(prompt, return_tensors="pt", max_length=512, truncation=True)
+        # Encode input
+        inputs = tokenizer.encode(
+            prompt, 
+            return_tensors="pt", 
+            max_length=400, 
+            truncation=True
+        )
         
+        # Generate
         with torch.no_grad():
             outputs = model.generate(
                 inputs,
-                max_length=min(max_length + len(inputs[0]), 512),
+                max_length=min(inputs.shape[1] + max_length, 500),
                 temperature=max(0.1, min(2.0, temperature)),
                 top_p=max(0.1, min(1.0, top_p)),
                 top_k=max(1, min(100, top_k)),
                 do_sample=True,
                 pad_token_id=tokenizer.eos_token_id,
-                num_return_sequences=1
+                num_return_sequences=1,
+                no_repeat_ngram_size=2
             )
         
-        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        result = generated_text[len(prompt):].strip()
+        # Decode result
+        generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        result = generated[len(prompt):].strip()
         
-        print(f"✅ Generation successful, length: {len(result)} chars")
-        return result
+        print(f"✅ Generated {len(result)} characters")
+        return result if result else "❌ No text generated"
         
     except Exception as e:
-        error_msg = f"❌ Generation error: {str(e)}"
-        print(error_msg)
-        return error_msg
+        error = f"❌ Generation failed: {str(e)}"
+        print(error)
+        return error
 
-# Create Gradio interface - FIXED VERSION with proper CSS and configuration
-with gr.Blocks(
-    title="🔐 Secure GPT-2 Generator",
-    theme=gr.themes.Soft(),  # Use a built-in theme to avoid i18n issues
-    css="""
-        .gradio-container {
-            max-width: 1200px !important;
-        }
-        .security-status {
-            background: linear-gradient(45deg, #f0f8ff, #e6f3ff);
-            padding: 15px;
-            border-radius: 8px;
-            margin: 10px 0;
-        }
-    """
-) as demo:
-    
-    # Header
-    gr.HTML("<h1>🔐 Secure GPT-2 Text Generator</h1>")
+# Create simple interface - NO COMPLEX THEMES OR CSS
+demo = gr.Blocks(title="GPT-2 Text Generator")
+
+with demo:
+    # Simple header
+    gr.Markdown("# 🤖 GPT-2 Text Generator")
     
-    # Security status display
-    security_status = []
-    if HF_TOKEN:
-        security_status.append("🔑 HF Token Active")
+    # Security info
     if API_KEY:
-        security_status.append("🔒 API Authentication Enabled")
-    if ADMIN_PASSWORD:
-        security_status.append("👤 Admin Protection Active")
-    
-    if security_status:
-        gr.HTML(f"""
-            <div class="security-status">
-                <strong>Active Security Features:</strong><br>
-                {' • '.join(security_status)}
-            </div>
-        """)
+        gr.Markdown("🔒 **API Authentication Required**")
     else:
-        gr.HTML("""
-            <div class="security-status">
-                ⚠️ <strong>No security features enabled</strong> - running in public mode
-            </div>
-        """)
+        gr.Markdown("🔓 **Public Access Mode**")
     
     with gr.Row():
-        with gr.Column(scale=1):
-            prompt_input = gr.Textbox(
-                label="✏️ Text Prompt",
-                placeholder="Enter your prompt here... (max 1000 chars)",
+        with gr.Column():
+            # Input section
+            prompt = gr.Textbox(
+                label="Prompt", 
+                placeholder="Enter your text prompt...",
                 lines=3
             )
             
-            # Show API key input only if API_KEY is configured
+            # API key input (only if needed)
             if API_KEY:
-                api_key_input = gr.Textbox(
-                    label="🔑 API Key (Required)",
+                api_key = gr.Textbox(
+                    label="API Key",
                     type="password",
-                    placeholder="Enter your API key..."
+                    placeholder="Enter API key..."
                 )
-                gr.HTML("<p><em>API authentication is enabled for this Space</em></p>")
             else:
-                api_key_input = gr.Textbox(value="", visible=False)
-                gr.HTML("<p>🔓 <strong>Public Access:</strong> No API key required</p>")
+                api_key = gr.Textbox(value="", visible=False)
             
-            with gr.Accordion("⚙️ Generation Parameters", open=False):
-                max_length = gr.Slider(
-                    minimum=10,
-                    maximum=200,
-                    value=100,
-                    step=10,
-                    label="📏 Max Length"
-                )
-                temperature = gr.Slider(
-                    minimum=0.1,
-                    maximum=2.0,
-                    value=0.7,
-                    step=0.1,
-                    label="🌡️ Temperature"
-                )
-                top_p = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.0,
-                    value=0.9,
-                    step=0.1,
-                    label="🎯 Top-p"
-                )
-                top_k = gr.Slider(
-                    minimum=1,
-                    maximum=100,
-                    value=50,
-                    step=1,
-                    label="🔢 Top-k"
-                )
+            # Parameters
+            max_length = gr.Slider(
+                10, 200, 100, 
+                label="Max Length"
+            )
+            temperature = gr.Slider(
+                0.1, 2.0, 0.7, 
+                label="Temperature"
+            )
+            top_p = gr.Slider(
+                0.1, 1.0, 0.9, 
+                label="Top-p"
+            )
+            top_k = gr.Slider(
+                1, 100, 50, 
+                label="Top-k"
+            )
             
-            generate_btn = gr.Button("🚀 Generate Text", variant="primary")
+            # Generate button
+            generate_btn = gr.Button("Generate", variant="primary")
         
-        with gr.Column(scale=1):
-            output_text = gr.Textbox(
-                label="📄 Generated Text",
-                lines=12,
+        with gr.Column():
+            # Output
+            output = gr.Textbox(
+                label="Generated Text",
+                lines=10,
                 placeholder="Generated text will appear here..."
             )
-            
-            # Rate limit info
-            if API_KEY:
-                gr.HTML("<p><strong>Rate Limits:</strong> 100 requests per hour per API key</p>")
     
     # Examples
-    with gr.Row():
-        gr.Examples(
-            examples=[
-                ["Once upon a time in a distant galaxy,"],
-                ["The future of artificial intelligence is"],
-                ["In the heart of the ancient forest,"],
-                ["The detective walked into the room and noticed"],
-                ["Write a short story about a robot who dreams of"],
-            ],
-            inputs=prompt_input,
-            label="💡 Example Prompts"
-        )
+    gr.Examples([
+        ["Once upon a time"],
+        ["The future of AI is"],
+        ["In a world where technology"],
+    ], inputs=prompt)
     
-    # Connect the generation function
+    # Connect function
     generate_btn.click(
-        fn=generate_text,
-        inputs=[prompt_input, max_length, temperature, top_p, top_k, api_key_input],
-        outputs=output_text
+        generate_text,
+        inputs=[prompt, max_length, temperature, top_p, top_k, api_key],
+        outputs=output
     )
 
-# Launch configuration - FIXED VERSION
+# Simple launch - MINIMAL CONFIGURATION
 if __name__ == "__main__":
-    # Determine authentication
-    auth_tuple = None
-    if ADMIN_PASSWORD:
-        auth_tuple = ("admin", ADMIN_PASSWORD)
-        print("🔐 Admin authentication enabled")
+    auth = ("admin", ADMIN_PASSWORD) if ADMIN_PASSWORD else None
     
-    # Launch with proper configuration for HF Spaces
-    try:
-        demo.launch(
-            auth=auth_tuple,
-            server_name="0.0.0.0",  # Allow external connections
-            server_port=7860,        # Standard HF Spaces port
-            show_api=True,           # Enable API documentation
-            show_error=True,         # Show detailed errors
-            share=False,             # Don't create ngrok tunnel (HF handles this)
-            inbrowser=False,         # Don't try to open browser
-            prevent_thread_lock=False,
-            ssr_mode=False           # Disable SSR to prevent i18n issues
-        )
-        print("🚀 Secure GPT-2 Generator is running!")
-    except Exception as e:
-        print(f"❌ Launch error: {e}")
-        # Fallback launch configuration
-        print("🔄 Trying fallback configuration...")
-        demo.launch(
-            auth=auth_tuple,
-            show_api=True,
-            ssr_mode=False
-        )
+    if auth:
+        print("🔐 Admin auth enabled")
+    
+    print("🚀 Starting server...")
+    
+    # MINIMAL launch config that works on HF Spaces
+    demo.launch(auth=auth)
+    
+    print("✅ Server running!")

requirements.txt

@@ -1,7 +1,4 @@
-gradio>=4.0.0
-transformers>=4.21.0
-torch>=1.12.0
-fastapi>=0.68.0
-uvicorn>=0.15.0
-pydantic>=1.8.0
-python-multipart>=0.0.5
+gradio
+transformers
+torch
+tokenizers