Spaces:
Runtime error
Runtime error
| """ | |
| 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 | |
| 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. | |
| Malicious code can harm the system. Use at your own risk. | |
| """ | |
| import os | |
| import io | |
| import sys | |
| import subprocess | |
| import socket | |
| import requests | |
| import httpx | |
| from openai import OpenAI | |
| import anthropic | |
| import gradio as gr | |
| # Try to load from .env file if available | |
| try: | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| except ImportError: | |
| pass | |
| # PASSWORD PROTECTION | |
| # Set this as a Hugging Face Secret: APP_PASSWORD | |
| APP_PASSWORD = os.environ.get("APP_PASSWORD", "demo123") # Change default! | |
| # Lazy initialization of AI clients with explicit HTTP client to avoid Gradio conflicts | |
| def get_openai_client(): | |
| api_key = os.environ.get("OPENAI_API_KEY") | |
| if not api_key: | |
| raise ValueError("OPENAI_API_KEY not found. Please set it in your environment or .env file.") | |
| # Create a clean HTTP client without proxies to avoid Gradio conflicts | |
| http_client = httpx.Client( | |
| timeout=60.0, | |
| limits=httpx.Limits(max_keepalive_connections=5, max_connections=10) | |
| ) | |
| return OpenAI(api_key=api_key, http_client=http_client) | |
| def get_claude_client(): | |
| api_key = os.environ.get("ANTHROPIC_API_KEY") | |
| if not api_key: | |
| raise ValueError("ANTHROPIC_API_KEY not found. Please set it in your environment or .env file.") | |
| # Create a clean HTTP client without proxies to avoid Gradio conflicts | |
| http_client = httpx.Client( | |
| timeout=60.0, | |
| limits=httpx.Limits(max_keepalive_connections=5, max_connections=10) | |
| ) | |
| return anthropic.Anthropic(api_key=api_key, http_client=http_client) | |
| # Model configurations | |
| 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++. " | |
| "Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. " | |
| "The C++ response needs to produce an identical output in the fastest possible time." | |
| ) | |
| def user_prompt_for(python): | |
| user_prompt = ( | |
| "Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. " | |
| "Respond only with C++ code; do not explain your work other than a few comments. " | |
| "Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\n\n" | |
| ) | |
| user_prompt += python | |
| return user_prompt | |
| def messages_for(python): | |
| return [ | |
| {"role": "system", "content": system_message}, | |
| {"role": "user", "content": user_prompt_for(python)} | |
| ] | |
| def write_output(cpp): | |
| """Write C++ code to file for compilation""" | |
| code = cpp.replace("```cpp","").replace("```","") | |
| with open("optimized.cpp", "w") as f: | |
| f.write(code) | |
| def stream_gpt(python): | |
| """Stream GPT-4o response""" | |
| try: | |
| client = get_openai_client() | |
| stream = client.chat.completions.create( | |
| model=OPENAI_MODEL, | |
| messages=messages_for(python), | |
| stream=True | |
| ) | |
| reply = "" | |
| for chunk in stream: | |
| fragment = chunk.choices[0].delta.content or "" | |
| reply += fragment | |
| yield reply.replace('```cpp\n','').replace('```','') | |
| except ValueError as e: | |
| yield f"❌ Error: {str(e)}" | |
| except Exception as e: | |
| yield f"❌ Error: {str(e)}" | |
| def stream_claude(python): | |
| """Stream Claude response""" | |
| try: | |
| client = get_claude_client() | |
| result = client.messages.stream( | |
| model=CLAUDE_MODEL, | |
| max_tokens=2000, | |
| system=system_message, | |
| messages=[{"role": "user", "content": user_prompt_for(python)}], | |
| ) | |
| reply = "" | |
| with result as stream: | |
| for text in stream.text_stream: | |
| reply += text | |
| yield reply.replace('```cpp\n','').replace('```','') | |
| except ValueError as e: | |
| yield f"❌ Error: {str(e)}" | |
| 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}") | |
| for stream_so_far in result: | |
| yield stream_so_far | |
| def execute_python(code): | |
| """⚠️ WARNING: Executes arbitrary Python code""" | |
| try: | |
| output = io.StringIO() | |
| sys.stdout = output | |
| exec(code) | |
| finally: | |
| sys.stdout = sys.__stdout__ | |
| return output.getvalue() | |
| def execute_cpp(code): | |
| """⚠️ WARNING: Compiles and executes arbitrary C++ code""" | |
| write_output(code) | |
| try: | |
| compile_cmd = ["g++", "-O3", "-std=c++17", "-o", "optimized", "optimized.cpp"] | |
| compile_result = subprocess.run( | |
| compile_cmd, | |
| check=True, | |
| text=True, | |
| capture_output=True, | |
| timeout=30 | |
| ) | |
| run_cmd = ["./optimized"] | |
| run_result = subprocess.run( | |
| run_cmd, | |
| check=True, | |
| text=True, | |
| capture_output=True, | |
| timeout=30 | |
| ) | |
| return run_result.stdout | |
| except subprocess.TimeoutExpired: | |
| return "⚠️ Execution timed out (30 seconds limit)" | |
| except subprocess.CalledProcessError as e: | |
| return f"❌ An error occurred:\n{e.stderr}" | |
| except Exception as e: | |
| return f"❌ Unexpected error: {str(e)}" | |
| # Example Python code | |
| default_python = """import time | |
| def calculate(iterations, param1, param2): | |
| result = 1.0 | |
| for i in range(1, iterations+1): | |
| j = i * param1 - param2 | |
| result -= (1/j) | |
| j = i * param1 + param2 | |
| result += (1/j) | |
| return result | |
| start_time = time.time() | |
| result = calculate(100_000_000, 4, 1) * 4 | |
| end_time = time.time() | |
| print(f"Result: {result:.12f}") | |
| print(f"Execution Time: {(end_time - start_time):.6f} seconds") | |
| """ | |
| # Modern CSS | |
| modern_css = """ | |
| .gradio-container { | |
| max-width: 1400px !important; | |
| margin: 0 auto !important; | |
| font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; | |
| } | |
| .modern-header { | |
| background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); | |
| color: white; | |
| padding: 24px; | |
| border-radius: 16px; | |
| margin-bottom: 24px; | |
| text-align: center; | |
| box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1); | |
| } | |
| .modern-header h1 { | |
| margin: 0; | |
| font-size: 32px; | |
| font-weight: 700; | |
| letter-spacing: -0.5px; | |
| } | |
| .modern-header p { | |
| margin: 12px 0 0 0; | |
| opacity: 0.9; | |
| font-size: 18px; | |
| font-weight: 400; | |
| } | |
| .security-warning { | |
| background: #fee2e2 !important; | |
| border: 2px solid #dc2626 !important; | |
| border-radius: 12px !important; | |
| padding: 16px !important; | |
| margin: 16px 0 !important; | |
| } | |
| .python-input { | |
| background: #f8fafc !important; | |
| border: 2px solid #e2e8f0 !important; | |
| border-radius: 12px !important; | |
| padding: 16px !important; | |
| font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important; | |
| font-size: 14px !important; | |
| color: #1e293b !important; | |
| line-height: 1.5 !important; | |
| } | |
| .python-input:focus { | |
| border-color: #3b82f6 !important; | |
| box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1) !important; | |
| } | |
| .cpp-output { | |
| background: #f1f5f9 !important; | |
| border: 2px solid #cbd5e1 !important; | |
| border-radius: 12px !important; | |
| padding: 16px !important; | |
| font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important; | |
| font-size: 14px !important; | |
| color: #0f172a !important; | |
| line-height: 1.5 !important; | |
| } | |
| .model-selector { | |
| background: white !important; | |
| border: 2px solid #e2e8f0 !important; | |
| border-radius: 12px !important; | |
| padding: 12px 16px !important; | |
| font-size: 16px !important; | |
| color: #374151 !important; | |
| } | |
| .model-selector:focus { | |
| border-color: #3b82f6 !important; | |
| box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1) !important; | |
| } | |
| .modern-button { | |
| background: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%) !important; | |
| color: white !important; | |
| border: none !important; | |
| border-radius: 12px !important; | |
| padding: 14px 28px !important; | |
| font-weight: 600 !important; | |
| font-size: 16px !important; | |
| cursor: pointer !important; | |
| transition: all 0.2s ease !important; | |
| box-shadow: 0 4px 6px rgba(59, 130, 246, 0.2) !important; | |
| } | |
| .modern-button:hover { | |
| transform: translateY(-2px) !important; | |
| box-shadow: 0 8px 12px rgba(59, 130, 246, 0.3) !important; | |
| } | |
| .run-button { | |
| background: linear-gradient(135deg, #10b981 0%, #059669 100%) !important; | |
| color: white !important; | |
| border: none !important; | |
| border-radius: 10px !important; | |
| padding: 12px 24px !important; | |
| font-weight: 600 !important; | |
| font-size: 14px !important; | |
| cursor: pointer !important; | |
| transition: all 0.2s ease !important; | |
| box-shadow: 0 4px 6px rgba(16, 185, 129, 0.2) !important; | |
| } | |
| .run-button:hover { | |
| transform: translateY(-1px) !important; | |
| box-shadow: 0 6px 8px rgba(16, 185, 129, 0.3) !important; | |
| } | |
| .output-section { | |
| background: #f8fafc; | |
| border: 1px solid #e2e8f0; | |
| border-radius: 12px; | |
| padding: 16px; | |
| margin: 12px 0; | |
| font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; | |
| font-size: 13px; | |
| line-height: 1.4; | |
| color: #374151; | |
| min-height: 100px; | |
| overflow-y: auto; | |
| } | |
| .python-output { | |
| background: #fef3c7 !important; | |
| border: 2px solid #f59e0b !important; | |
| color: #92400e !important; | |
| } | |
| .cpp-output-result { | |
| background: #dbeafe !important; | |
| border: 2px solid #3b82f6 !important; | |
| color: #1e40af !important; | |
| } | |
| .performance-card { | |
| background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%); | |
| border: 1px solid #0ea5e9; | |
| border-radius: 12px; | |
| padding: 20px; | |
| margin: 16px 0; | |
| text-align: center; | |
| } | |
| .performance-card h3 { | |
| margin: 0 0 12px 0; | |
| color: #0c4a6e; | |
| font-size: 18px; | |
| font-weight: 600; | |
| } | |
| .performance-metric { | |
| display: inline-block; | |
| background: white; | |
| border-radius: 8px; | |
| padding: 8px 16px; | |
| margin: 4px; | |
| font-weight: 600; | |
| color: #0c4a6e; | |
| box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); | |
| } | |
| """ | |
| # Create the interface with password protection | |
| def create_interface(): | |
| with gr.Blocks(css=modern_css, title="Python to C++ Code Optimizer", theme=gr.themes.Soft()) as app: | |
| # Header Section | |
| gr.HTML(""" | |
| <div class="modern-header"> | |
| <h1>🚀 Python to C++ Code Optimizer</h1> | |
| <p>AI-powered code conversion with real-time execution and performance analysis</p> | |
| </div> | |
| """) | |
| # Security Warning | |
| gr.HTML(""" | |
| <div class="security-warning"> | |
| <h3 style="color: #dc2626; margin: 0 0 8px 0;">⚠️ Security Warning</h3> | |
| <p style="margin: 0; color: #991b1b; font-weight: 500;"> | |
| This interface executes arbitrary code. <strong>Only run code from trusted sources.</strong><br> | |
| Malicious code can harm your system. Use at your own risk. | |
| </p> | |
| </div> | |
| """) | |
| # Main Content Area | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### 📝 Python Code Input") | |
| python_input = gr.Textbox( | |
| label="Python Code:", | |
| value=default_python, | |
| lines=15, | |
| placeholder="Enter your Python code here...", | |
| elem_classes=["python-input"], | |
| show_copy_button=True | |
| ) | |
| 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"] | |
| ) | |
| convert_btn = gr.Button("🔄 Convert to C++", elem_classes=["modern-button"]) | |
| with gr.Column(scale=1): | |
| gr.Markdown("### ⚡ Generated C++ Code") | |
| cpp_output = gr.Textbox( | |
| label="C++ Code:", | |
| lines=15, | |
| placeholder="Generated C++ code will appear here...", | |
| elem_classes=["cpp-output"], | |
| show_copy_button=True | |
| ) | |
| # Execution Section | |
| 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(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..." | |
| ) | |
| # 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 | |
| ) | |
| python_run_btn.click( | |
| execute_python, | |
| inputs=[python_input], | |
| outputs=[python_result], | |
| show_progress=True | |
| ) | |
| cpp_run_btn.click( | |
| execute_cpp, | |
| inputs=[cpp_output], | |
| outputs=[cpp_result], | |
| show_progress=True | |
| ) | |
| return app | |
| # Launch with password protection | |
| if __name__ == "__main__": | |
| app = create_interface() | |
| # Check if running on Hugging Face Spaces | |
| is_huggingface = os.getenv("SPACE_ID") is not None | |
| if is_huggingface: | |
| # Hugging Face Spaces configuration | |
| print(f"🚀 Launching Python to C++ Code Optimizer on Hugging Face Spaces") | |
| print(f"🔐 Password protection enabled") | |
| app.launch( | |
| auth=("user", APP_PASSWORD), | |
| auth_message="🔐 Enter credentials to access the Python to C++ Code Optimizer" | |
| ) | |
| 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 | |
| free_port = find_free_port() | |
| print(f"🚀 Launching Python to C++ Code Optimizer on port: {free_port}") | |
| print(f"🔐 Password protection enabled") | |
| # Launch with authentication | |
| app.launch( | |
| inbrowser=True, | |
| share=False, | |
| server_name="127.0.0.1", | |
| server_port=free_port, | |
| show_error=True, | |
| auth=("user", APP_PASSWORD), | |
| auth_message="🔐 Enter credentials to access the Python to C++ Code Optimizer" | |
| ) | |