Delete app.py

app.py

@@ -1,407 +0,0 @@
-"""
-🔥 GOD Coding Machine - Gradio App
-Deploy with: gradio deploy
-
-Uses FREE HuggingFace Inference API to access powerful coding models.
-"""
-
-import gradio as gr
-from huggingface_hub import InferenceClient
-import os
-
-# Initialize the client - uses HF Inference API (FREE!)
-# You can set HF_TOKEN as environment variable or it uses anonymous access
-HF_TOKEN = os.getenv("HF_TOKEN", None)
-
-# Best FREE models for coding via HF Inference API
-MODELS = {
-    "Qwen2.5-Coder-32B (Best)": "Qwen/Qwen2.5-Coder-32B-Instruct",
-    "Qwen2.5-Coder-7B (Fast)": "Qwen/Qwen2.5-Coder-7B-Instruct", 
-    "CodeLlama-34B": "codellama/CodeLlama-34b-Instruct-hf",
-    "Mistral-7B": "mistralai/Mistral-7B-Instruct-v0.3",
-    "Llama-3.1-8B": "meta-llama/Llama-3.1-8B-Instruct",
-}
-
-DEFAULT_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
-
-def get_client(model_id: str) -> InferenceClient:
-    """Get inference client for a model"""
-    return InferenceClient(model_id, token=HF_TOKEN)
-
-def chat_with_model(message: str, history: list, model_name: str, temperature: float, max_tokens: int):
-    """Stream chat responses from the model"""
-    
-    model_id = MODELS.get(model_name, DEFAULT_MODEL)
-    client = get_client(model_id)
-    
-    # Build messages
-    messages = [
-        {
-            "role": "system",
-            "content": """You are an expert coding assistant. You help with:
-- Writing clean, efficient, well-documented code
-- Debugging and fixing issues  
-- Explaining code and programming concepts
-- Code reviews and best practices
-- Answering programming questions
-
-Always provide code examples in markdown code blocks with the language specified."""
-        }
-    ]
-    
-    # Add history
-    for user_msg, assistant_msg in history:
-        messages.append({"role": "user", "content": user_msg})
-        if assistant_msg:
-            messages.append({"role": "assistant", "content": assistant_msg})
-    
-    # Add current message
-    messages.append({"role": "user", "content": message})
-    
-    # Stream the response
-    try:
-        response = ""
-        for chunk in client.chat_completion(
-            messages=messages,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            stream=True
-        ):
-            if chunk.choices[0].delta.content:
-                response += chunk.choices[0].delta.content
-                yield response
-    except Exception as e:
-        yield f"❌ Error: {str(e)}\n\nTip: Try a different model or check your connection."
-
-def generate_code(prompt: str, language: str, model_name: str):
-    """Generate code from a description"""
-    
-    if not prompt.strip():
-        return "Please describe what you want to build."
-    
-    model_id = MODELS.get(model_name, DEFAULT_MODEL)
-    client = get_client(model_id)
-    
-    full_prompt = f"""Write {language} code for the following:
-
-{prompt}
-
-Requirements:
-- Clean, readable, well-commented code
-- Follow {language} best practices
-- Include error handling where appropriate
-
-Respond with ONLY the code in a markdown code block, no explanations."""
-
-    try:
-        response = client.chat_completion(
-            messages=[{"role": "user", "content": full_prompt}],
-            max_tokens=2048,
-            temperature=0.3
-        )
-        
-        result = response.choices[0].message.content
-        
-        # Extract code from markdown block if present
-        if "```" in result:
-            # Find code between ``` markers
-            parts = result.split("```")
-            if len(parts) >= 2:
-                code_part = parts[1]
-                # Remove language identifier if present
-                if code_part.startswith(language.lower()) or code_part.startswith("\n"):
-                    code_part = code_part.split("\n", 1)[-1] if "\n" in code_part else code_part
-                return code_part.strip()
-        
-        return result
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def explain_code(code: str, model_name: str):
-    """Explain code in detail"""
-    
-    if not code.strip():
-        return "Please paste some code to explain."
-    
-    model_id = MODELS.get(model_name, DEFAULT_MODEL)
-    client = get_client(model_id)
-    
-    prompt = f"""Analyze and explain this code in detail:
-
-```
-{code}
-```
-
-Please provide:
-1. **Purpose**: What does this code do?
-2. **How it works**: Step-by-step explanation
-3. **Key concepts**: Important programming concepts used
-4. **Complexity**: Time and space complexity if applicable
-5. **Potential improvements**: Suggestions for better code"""
-
-    try:
-        response = client.chat_completion(
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=2048,
-            temperature=0.5
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def fix_code(code: str, error_msg: str, model_name: str):
-    """Fix buggy code"""
-    
-    if not code.strip():
-        return "Please paste the code you want to fix."
-    
-    model_id = MODELS.get(model_name, DEFAULT_MODEL)
-    client = get_client(model_id)
-    
-    prompt = f"""Fix the following buggy code:
-
-**Code:**
-```
-{code}
-```
-
-**Error/Problem:**
-{error_msg if error_msg.strip() else "The code doesn't work correctly"}
-
-Please:
-1. Identify what's wrong
-2. Explain the bug
-3. Provide the corrected code in a code block
-4. Explain the fix"""
-
-    try:
-        response = client.chat_completion(
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=2048,
-            temperature=0.3
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def review_code(code: str, model_name: str):
-    """Review code and suggest improvements"""
-    
-    if not code.strip():
-        return "Please paste code to review."
-    
-    model_id = MODELS.get(model_name, DEFAULT_MODEL)
-    client = get_client(model_id)
-    
-    prompt = f"""Review this code and provide feedback:
-
-```
-{code}
-```
-
-Please evaluate:
-1. **Code Quality**: Is it clean, readable, well-organized?
-2. **Best Practices**: Does it follow language conventions?
-3. **Bugs/Issues**: Any potential bugs or problems?
-4. **Performance**: Any performance concerns?
-5. **Security**: Any security issues?
-6. **Suggestions**: Specific improvements with code examples
-
-Be constructive and specific."""
-
-    try:
-        response = client.chat_completion(
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=2048,
-            temperature=0.5
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-
-# ============== BUILD THE UI ==============
-
-with gr.Blocks(
-    title="🔥 GOD Coding Machine",
-    theme=gr.themes.Soft(primary_hue="purple", secondary_hue="blue"),
-) as demo:
-    
-    gr.Markdown("""
-    # 🔥 FREE GOD Coding Machine
-    ### AI Coding Assistant - Powered by Open Source Models via HuggingFace
-    
-    **100% FREE** • Uses HuggingFace Inference API • No API key required (or add your own for higher limits)
-    """)
-    
-    # Settings row
-    with gr.Row():
-        model_dropdown = gr.Dropdown(
-            choices=list(MODELS.keys()),
-            value="Qwen2.5-Coder-32B (Best)",
-            label="🤖 Model",
-            scale=2
-        )
-        temperature = gr.Slider(
-            minimum=0.0, maximum=1.0, value=0.7, step=0.1,
-            label="🌡️ Temperature",
-            scale=1
-        )
-        max_tokens = gr.Slider(
-            minimum=256, maximum=4096, value=2048, step=256,
-            label="📏 Max Tokens",
-            scale=1
-        )
-    
-    with gr.Tabs():
-        
-        # ===== CHAT TAB =====
-        with gr.TabItem("💬 Chat"):
-            chatbot = gr.Chatbot(
-                height=450,
-                show_label=False,
-                avatar_images=(None, "https://em-content.zobj.net/source/twitter/376/robot_1f916.png"),
-                bubble_full_width=False
-            )
-            
-            with gr.Row():
-                msg = gr.Textbox(
-                    placeholder="Ask me anything about coding... (Press Enter to send)",
-                    show_label=False,
-                    scale=9,
-                    container=False
-                )
-                send_btn = gr.Button("Send", variant="primary", scale=1)
-            
-            clear_btn = gr.Button("🗑️ Clear Chat")
-            
-            gr.Examples(
-                examples=[
-                    "Write a Python function to find the longest palindromic substring",
-                    "Explain how async/await works in JavaScript",
-                    "What's the difference between a list and a tuple in Python?",
-                    "Write a REST API in FastAPI with CRUD operations for a todo app",
-                    "How do I implement a binary search tree?",
-                ],
-                inputs=msg
-            )
-        
-        # ===== GENERATE TAB =====
-        with gr.TabItem("⚡ Generate Code"):
-            with gr.Row():
-                with gr.Column():
-                    gen_prompt = gr.Textbox(
-                        label="📝 Describe what you want to build",
-                        placeholder="A function that validates email addresses...",
-                        lines=4
-                    )
-                    gen_lang = gr.Dropdown(
-                        choices=["Python", "JavaScript", "TypeScript", "Rust", "Go", "Java", "C++", "C#", "Ruby", "PHP", "Swift", "Kotlin", "SQL", "Bash"],
-                        value="Python",
-                        label="💻 Language"
-                    )
-                    gen_btn = gr.Button("🚀 Generate Code", variant="primary", size="lg")
-                
-                with gr.Column():
-                    gen_output = gr.Code(label="Generated Code", language="python", lines=20)
-            
-            gr.Examples(
-                examples=[
-                    ["A function to merge two sorted linked lists", "Python"],
-                    ["A React hook for debouncing input", "TypeScript"],
-                    ["A function to validate a credit card number using Luhn algorithm", "JavaScript"],
-                    ["A thread-safe singleton pattern", "Java"],
-                ],
-                inputs=[gen_prompt, gen_lang]
-            )
-        
-        # ===== EXPLAIN TAB =====
-        with gr.TabItem("🔍 Explain Code"):
-            with gr.Row():
-                with gr.Column():
-                    explain_input = gr.Code(
-                        label="📋 Paste code to explain",
-                        language="python",
-                        lines=15
-                    )
-                    explain_btn = gr.Button("🔍 Explain", variant="primary", size="lg")
-                
-                with gr.Column():
-                    explain_output = gr.Markdown(label="Explanation")
-        
-        # ===== FIX TAB =====
-        with gr.TabItem("🔧 Fix Code"):
-            with gr.Row():
-                with gr.Column():
-                    fix_input = gr.Code(
-                        label="🐛 Paste buggy code",
-                        language="python",
-                        lines=12
-                    )
-                    fix_error = gr.Textbox(
-                        label="❌ Error message (optional)",
-                        placeholder="Paste the error message...",
-                        lines=3
-                    )
-                    fix_btn = gr.Button("🔧 Fix Code", variant="primary", size="lg")
-                
-                with gr.Column():
-                    fix_output = gr.Markdown(label="Solution")
-        
-        # ===== REVIEW TAB =====
-        with gr.TabItem("📝 Code Review"):
-            with gr.Row():
-                with gr.Column():
-                    review_input = gr.Code(
-                        label="📋 Paste code to review",
-                        language="python",
-                        lines=15
-                    )
-                    review_btn = gr.Button("📝 Review Code", variant="primary", size="lg")
-                
-                with gr.Column():
-                    review_output = gr.Markdown(label="Review")
-    
-    # Footer
-    gr.Markdown("""
-    ---
-    <center>
-    
-    **Models**: [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) (32B) • [CodeLlama](https://huggingface.co/codellama) (34B) • [Mistral](https://huggingface.co/mistralai) (7B)
-    
-    💡 **Tip**: Add your HuggingFace token as `HF_TOKEN` secret for higher rate limits
-    
-    </center>
-    """)
-    
-    # ===== EVENT HANDLERS =====
-    
-    def respond(message, history, model, temp, max_tok):
-        history = history or []
-        response = ""
-        for chunk in chat_with_model(message, history, model, temp, max_tok):
-            response = chunk
-            yield history + [[message, response]], ""
-    
-    # Chat events
-    msg.submit(respond, [msg, chatbot, model_dropdown, temperature, max_tokens], [chatbot, msg])
-    send_btn.click(respond, [msg, chatbot, model_dropdown, temperature, max_tokens], [chatbot, msg])
-    clear_btn.click(lambda: [], None, chatbot)
-    
-    # Generate events
-    gen_btn.click(generate_code, [gen_prompt, gen_lang, model_dropdown], gen_output)
-    
-    # Explain events
-    explain_btn.click(explain_code, [explain_input, model_dropdown], explain_output)
-    
-    # Fix events
-    fix_btn.click(fix_code, [fix_input, fix_error, model_dropdown], fix_output)
-    
-    # Review events
-    review_btn.click(review_code, [review_input, model_dropdown], review_output)
-
-
-# Launch
-if __name__ == "__main__":
-    demo.launch()