Upload 2 files

app.py

@@ -1,13 +1,10 @@
 """
-Python to C++ Code Optimizer - Modern UI with Password Protection
-AI-powered code conversion using GPT-4o, Claude-3.5-Sonnet, and Open Source models
+Python to C++ Code Optimizer - AI-Powered Code Conversion
+Modern Gradio app with password protection for secure deployments
 
 Supported Models:
 - GPT-4o (OpenAI) - Premium, fastest, most accurate
 - Claude-3.5-Sonnet (Anthropic) - Premium, excellent for code
-- CodeLlama-34B (Meta) - Open source, free/cheap
-- DeepSeek-Coder-33B - Open source, excellent for code
-- Mistral-7B - Open source, fast, general purpose
 
 ⚠️ SECURITY WARNING:
 This app executes arbitrary code. Only run code from trusted sources.
@@ -19,7 +16,6 @@ import io
 import sys
 import subprocess
 import socket
-import requests
 import httpx
 from openai import OpenAI
 import anthropic
@@ -67,16 +63,6 @@ def get_claude_client():
 OPENAI_MODEL = "gpt-4o"
 CLAUDE_MODEL = "claude-3-5-sonnet-20240620"
 
-# Hugging Face models (open source)
-HF_MODELS = {
-    "CodeLlama-34B": "codellama/CodeLlama-34b-Instruct-hf",
-    "DeepSeek-Coder-33B": "deepseek-ai/deepseek-coder-33b-instruct",
-    "Mistral-7B": "mistralai/Mistral-7B-Instruct-v0.2"
-}
-
-# Hugging Face API endpoint
-HF_API_URL = "https://api-inference.huggingface.co/models/"
-
 # System and user prompts
 system_message = (
     "You are an assistant that reimplements Python code in high performance C++. "
@@ -144,129 +130,12 @@ def stream_claude(python):
     except Exception as e:
         yield f"❌ Error: {str(e)}"
 
-def stream_huggingface(python, model_name):
-    """Stream Hugging Face model response"""
-    try:
-        # Get HF token (optional - works without it but with rate limits)
-        hf_token = os.environ.get("HF_TOKEN", "")
-        
-        # Debug info
-        if hf_token:
-            yield f"🔑 Using HF token (first 10 chars): {hf_token[:10]}...\n\n"
-        else:
-            yield f"⚠️ No HF_TOKEN found - using public API (limited)\n\n"
-        
-        # Get the model ID
-        model_id = HF_MODELS.get(model_name)
-        if not model_id:
-            yield f"❌ Unknown model: {model_name}"
-            return
-        
-        yield f"📡 Calling model: {model_id}\n\n"
-        
-        headers = {"Authorization": f"Bearer {hf_token}"} if hf_token else {}
-        
-        # Prepare the prompt
-        prompt = f"{system_message}\n\n{user_prompt_for(python)}"
-        
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": 2000,
-                "temperature": 0.7,
-                "return_full_text": False
-            }
-        }
-        
-        # Call HF Inference API
-        response = requests.post(
-            HF_API_URL + model_id,
-            headers=headers,
-            json=payload,
-            timeout=60
-        )
-        
-        # Check if response body is empty
-        if not response.text or len(response.text.strip()) == 0:
-            yield f"⏳ Model is loading or initializing...\n\n"
-            yield f"This happens on first use. Please try again in 30-60 seconds.\n\n"
-            yield f"💡 Quick alternative: Use GPT-4o or Claude-3.5-Sonnet (instant results!)"
-            return
-        
-        if response.status_code == 200:
-            try:
-                result = response.json()
-                if isinstance(result, list) and len(result) > 0:
-                    generated_text = result[0].get("generated_text", "")
-                else:
-                    generated_text = result.get("generated_text", "")
-                
-                if not generated_text or len(generated_text.strip()) == 0:
-                    yield f"⚠️ Model returned empty response.\n\n"
-                    yield f"Try again or use GPT-4o/Claude-3.5-Sonnet instead."
-                    return
-                
-                # Clean up the response
-                reply = generated_text.replace('```cpp\n','').replace('```','')
-                yield reply
-            except ValueError as json_err:
-                # JSON parsing failed
-                yield f"⚠️ Model response format error.\n\n"
-                yield f"The model might still be warming up. Try again in 30 seconds.\n\n"
-                yield f"💡 Or use GPT-4o/Claude-3.5-Sonnet for instant results!"
-                
-        elif response.status_code == 401 or response.status_code == 403:
-            # Authentication error - need HF token
-            yield f"🔑 Authentication Required!\n\n"
-            yield f"To use open-source models, you need a FREE Hugging Face token:\n\n"
-            yield f"1. Get token: https://huggingface.co/settings/tokens\n"
-            yield f"2. Add HF_TOKEN secret in Space Settings\n"
-            yield f"3. Factory reboot\n\n"
-            yield f"OR use GPT-4o/Claude-3.5-Sonnet instead (they work now!)"
-        elif response.status_code == 503:
-            # Service unavailable - model loading
-            yield f"⏳ Model is currently loading (cold start)...\n\n"
-            yield f"This can take 30-60 seconds on first use.\n"
-            yield f"Please wait a minute and try again.\n\n"
-            yield f"💡 Quick solution: Use GPT-4o or Claude-3.5-Sonnet (no waiting!)"
-        else:
-            try:
-                error_msg = response.json().get("error", "Unknown error")
-            except:
-                error_msg = response.text[:200] if response.text else "Empty response"
-            
-            if "loading" in str(error_msg).lower():
-                yield f"⏳ Model is loading... This may take 20-30 seconds. Please try again."
-            else:
-                yield f"❌ Error from Hugging Face (HTTP {response.status_code}):\n{error_msg}\n\n"
-                yield f"💡 Tip: Use GPT-4o or Claude-3.5-Sonnet for now (they're working!)"
-            
-    except requests.exceptions.Timeout as timeout_err:
-        yield f"⏱️ Request timed out: {str(timeout_err)}\n\n"
-        yield f"Model might be loading (cold start). Try again in 30-60 seconds.\n\n"
-        yield f"💡 Or use GPT-4o/Claude-3.5-Sonnet for instant results!"
-    except requests.exceptions.ConnectionError as conn_err:
-        yield f"🌐 Connection error: {str(conn_err)}\n\n"
-        yield f"Cannot reach Hugging Face API. Check your internet connection.\n\n"
-        yield f"💡 Please use GPT-4o or Claude-3.5-Sonnet instead."
-    except requests.exceptions.RequestException as req_err:
-        yield f"🌐 Network error: {str(req_err)}\n\n"
-        yield f"Type: {type(req_err).__name__}\n\n"
-        yield f"💡 Please use GPT-4o or Claude-3.5-Sonnet instead."
-    except Exception as e:
-        yield f"❌ Unexpected error: {str(e)}\n\n"
-        yield f"Error type: {type(e).__name__}\n"
-        yield f"Full details: {repr(e)}\n\n"
-        yield f"💡 Tip: Use GPT-4o or Claude-3.5-Sonnet for reliable results!"
-
 def optimize(python, model):
     """Convert Python to C++ using selected AI model"""
     if model in ["GPT-4o", "GPT"]:
         result = stream_gpt(python)
     elif model in ["Claude-3.5-Sonnet", "Claude"]:
         result = stream_claude(python)
-    elif model in HF_MODELS.keys():
-        result = stream_huggingface(python, model)
     else:
         raise ValueError(f"Unknown model: {model}")
     
@@ -534,95 +403,82 @@ def create_interface():
                     label="Python Code:", 
                     value=default_python, 
                     lines=15,
-                    placeholder="Enter your Python code here...",
                     elem_classes=["python-input"],
-                    show_copy_button=True
+                    placeholder="Enter your Python code here..."
                 )
                 
-                gr.Markdown("### 🤖 AI Model Selection")
-                model_selector = gr.Dropdown(
-                    ["GPT-4o", "Claude-3.5-Sonnet", "CodeLlama-34B", "DeepSeek-Coder-33B", "Mistral-7B"], 
-                    label="Select AI Model", 
-                    value="GPT-4o",
-                    elem_classes=["model-selector"]
-                )
+                with gr.Row():
+                    model_selector = gr.Dropdown(
+                        ["GPT-4o", "Claude-3.5-Sonnet"], 
+                        label="Select AI Model", 
+                        value="GPT-4o",
+                        elem_classes=["model-selector"]
+                    )
+                
+                convert_button = gr.Button("✨ Convert to C++", elem_classes=["modern-button"])
                 
-                convert_btn = gr.Button("🔄 Convert to C++", elem_classes=["modern-button"])
-            
             with gr.Column(scale=1):
-                gr.Markdown("### ⚡ Generated C++ Code")
+                gr.Markdown("### ⚡ Optimized C++ Code")
                 cpp_output = gr.Textbox(
-                    label="C++ Code:", 
+                    label="Generated C++ Code:", 
                     lines=15,
-                    placeholder="Generated C++ code will appear here...",
                     elem_classes=["cpp-output"],
-                    show_copy_button=True
+                    interactive=False
                 )
         
         # Execution Section
+        gr.Markdown("---")
+        gr.Markdown("## 🏃 Code Execution & Performance Comparison")
+        
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 🐍 Python Execution")
-                python_run_btn = gr.Button("▶️ Run Python", elem_classes=["run-button"])
-                python_result = gr.TextArea(
-                    label="Python Output:", 
-                    lines=8,
-                    elem_classes=["output-section", "python-output"],
-                    placeholder="Python execution results will appear here..."
+            with gr.Column():
+                gr.Markdown("### 🐍 Python Output")
+                run_python_button = gr.Button("▶️ Run Python", elem_classes=["run-button"])
+                python_output = gr.Textbox(
+                    label="Python Execution Output:",
+                    lines=5,
+                    elem_classes=["python-output"],
+                    interactive=False
                 )
             
-            with gr.Column(scale=1):
-                gr.Markdown("### 🚀 C++ Execution")
-                cpp_run_btn = gr.Button("▶️ Run C++", elem_classes=["run-button"])
-                cpp_result = gr.TextArea(
-                    label="C++ Output:", 
-                    lines=8,
-                    elem_classes=["output-section", "cpp-output-result"],
-                    placeholder="C++ execution results will appear here..."
+            with gr.Column():
+                gr.Markdown("### ⚡ C++ Output")
+                run_cpp_button = gr.Button("▶️ Run C++", elem_classes=["run-button"])
+                cpp_execution_output = gr.Textbox(
+                    label="C++ Execution Output:",
+                    lines=5,
+                    elem_classes=["cpp-output-result"],
+                    interactive=False
                 )
         
-        # Performance Metrics Section
-        gr.HTML("""
-        <div class="performance-card">
-            <h3>📊 Performance Comparison</h3>
-            <div>
-                <span class="performance-metric">Python: ~6.3s</span>
-                <span class="performance-metric">C++: ~0.6s</span>
-                <span class="performance-metric">Speedup: 10x</span>
-            </div>
-            <p style="margin: 12px 0 0 0; color: #64748b; font-size: 14px;">
-                Compare execution times and performance metrics between Python and C++ implementations.<br>
-                Typical speedup: 10-100x depending on the algorithm.
-            </p>
-        </div>
-        """)
-        
-        # Event Handlers
-        convert_btn.click(
-            optimize, 
-            inputs=[python_input, model_selector], 
-            outputs=[cpp_output],
-            show_progress=True
+        # Event handlers
+        convert_button.click(
+            fn=optimize,
+            inputs=[python_input, model_selector],
+            outputs=cpp_output
         )
         
-        python_run_btn.click(
-            execute_python, 
-            inputs=[python_input], 
-            outputs=[python_result],
-            show_progress=True
+        run_python_button.click(
+            fn=execute_python,
+            inputs=python_input,
+            outputs=python_output
         )
         
-        cpp_run_btn.click(
-            execute_cpp, 
-            inputs=[cpp_output], 
-            outputs=[cpp_result],
-            show_progress=True
+        run_cpp_button.click(
+            fn=execute_cpp,
+            inputs=cpp_output,
+            outputs=cpp_execution_output
         )
-    
+        
     return app
 
-# Launch with password protection
+# Launch the app
 if __name__ == "__main__":
+    print("\n" + "="*50)
+    print(f"===== Application Startup at {__import__('datetime').datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
+    print("="*50)
+    
+    # Create the app
     app = create_interface()
     
     # Check if running on Hugging Face Spaces
@@ -630,34 +486,34 @@ if __name__ == "__main__":
     
     if is_huggingface:
         # Hugging Face Spaces configuration
-        print(f"🚀 Launching Python to C++ Code Optimizer on Hugging Face Spaces")
-        print(f"🔐 Password protection enabled")
-        
+        print("🚀 Launching Python to C++ Code Optimizer on Hugging Face Spaces")
+        print("🔐 Password protection enabled")
         app.launch(
             auth=("user", APP_PASSWORD),
-            auth_message="🔐 Enter credentials to access the Python to C++ Code Optimizer"
+            show_error=True
         )
     else:
         # Local development configuration
-        def find_free_port():
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind(('', 0))
-                s.listen(1)
-                port = s.getsockname()[1]
-            return port
+        def get_available_port(start_port=7860):
+            """Find an available port starting from start_port"""
+            port = start_port
+            while port < start_port + 100:
+                try:
+                    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                        s.bind(('', port))
+                        return port
+                except OSError:
+                    port += 1
+            return start_port
         
-        free_port = find_free_port()
-        print(f"🚀 Launching Python to C++ Code Optimizer on port: {free_port}")
-        print(f"🔐 Password protection enabled")
+        port = get_available_port()
+        print(f"🚀 Launching Python to C++ Code Optimizer on port: {port}")
+        print(f"🔐 Password protection enabled. Password: {APP_PASSWORD}")
         
-        # Launch with authentication
         app.launch(
-            inbrowser=True,
-            share=False,
             server_name="127.0.0.1",
-            server_port=free_port,
-            show_error=True,
+            server_port=port,
             auth=("user", APP_PASSWORD),
-            auth_message="🔐 Enter credentials to access the Python to C++ Code Optimizer"
+            show_error=True
         )
 

requirements.txt

@@ -2,6 +2,5 @@ gradio==4.44.1
 openai==1.55.0
 anthropic==0.40.0
 python-dotenv==1.0.0
-requests>=2.31.0
 httpx>=0.27.0