Update app.py

app.py

@@ -1,7 +1,562 @@
 import gradio as gr
+import requests
+import os
+import logging
+import re
+import random
+import json
 
-def greet(name):
-    return "Hello " + name + "!!"
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# ======= CODE ANALYSIS CLASS ========
+class CodeRoaster:
+    def __init__(self):
+        # Roast templates for different levels
+        self.roast_templates = {
+            "Mild": [
+                "I see some opportunities for improvement in this code. It's not bad, but we can make it better!",
+                "This code would benefit from a few tweaks. Let me show you how.",
+                "Your code works, but there are some best practices we could apply here."
+            ],
+            "Medium": [
+                "This code looks like it was written the night before a deadline. Time for some tough love!",
+                "I've seen better code written by first-year CS students. Let's clean this up.",
+                "Your code needs a serious makeover. It's like showing up to a wedding in sweatpants."
+            ],
+            "Savage": [
+                "This code is what happens when Stack Overflow answers are copied without understanding. Pure chaos!",
+                "Did you write this code during a power outage? While blindfolded? On a keyboard missing half its keys?",
+                "If this code were a restaurant dish, Gordon Ramsay would throw it in the trash and shut down the kitchen."
+            ]
+        }
+        
+        # Issue templates for different languages
+        self.python_issue_detectors = [
+            {
+                'pattern': r"range\s*\(\s*0\s*,",
+                'issue': "unnecessary zero in range",
+                'suggestion': "range() starts at 0 by default, so range(0, n) can be simplified to range(n)",
+                'fix': lambda code: re.sub(r"range\s*\(\s*0\s*,\s*([^\)]+)\)", r"range(\1)", code)
+            },
+            {
+                'pattern': r"print\s*\(",
+                'issue': "print statements used for output",
+                'suggestion': "Consider using logging for better control in production environments",
+                'fix': lambda code: code  # No automatic fix
+            },
+            {
+                'pattern': r"if\s+\*\*name\*\*\s+==",
+                'issue': "incorrect __name__ syntax",
+                'suggestion': 'Use if __name__ == "__main__": instead of if **name** == "__main__":',
+                'fix': lambda code: re.sub(r"if\s+\*\*name\*\*\s+==", r"if __name__ ==", code)
+            },
+            {
+                'pattern': r"def\s+\w+\s*\([^\)]*\)\s*:\s*(?!\n\s*[\"\'])",
+                'issue': "missing docstring",
+                'suggestion': "Add docstrings to functions explaining purpose, parameters and return values",
+                'fix': lambda code: code  # No automatic fix, requires understanding function purpose
+            },
+            {
+                'pattern': r"  [^\n]+",
+                'issue': "inconsistent indentation",
+                'suggestion': "Use consistent indentation (4 spaces per level is the Python standard)",
+                'fix': lambda code: re.sub(r"  (?! {2})", r"    ", code)
+            },
+            {
+                'pattern': r"except:",
+                'issue': "bare except clause",
+                'suggestion': "Specify exceptions to catch instead of using a bare except clause",
+                'fix': lambda code: re.sub(r"except:", r"except Exception:", code)
+            },
+            {
+                'pattern': r"from\s+\w+\s+import\s+\*",
+                'issue': "wildcard import",
+                'suggestion': "Import specific modules or functions instead of using wildcard imports",
+                'fix': lambda code: code  # No automatic fix, requires knowledge of what's needed
+            },
+            {
+                'pattern': r"i\s*\+=\s*1",
+                'issue': "manual index increment in loop",
+                'suggestion': "Consider using enumerate() for clean iteration with indices",
+                'fix': lambda code: code  # No automatic fix, requires restructuring
+            },
+            {
+                'pattern': r"with\s+open\([^,]+\)\s+as",
+                'issue': "missing file mode in open()",
+                'suggestion': "Specify the file mode in open(filename, mode)",
+                'fix': lambda code: re.sub(r"with\s+open\(([^,]+)\)\s+as", r"with open(\1, 'r') as", code)
+            }
+        ]
+        
+        self.js_issue_detectors = [
+            {
+                'pattern': r"var\s+",
+                'issue': "using var instead of let/const",
+                'suggestion': "Use let for variables that change and const for variables that don't change",
+                'fix': lambda code: re.sub(r"var\s+", r"let ", code)  # Simple replacement, not always correct
+            },
+            {
+                'pattern': r"==(?!=)",
+                'issue': "loose equality operators",
+                'suggestion': "Use === instead of == for strict equality checking",
+                'fix': lambda code: re.sub(r"==(?!=)", r"===", code)
+            },
+            {
+                'pattern': r"console\.log\(",
+                'issue': "console.log statements left in code",
+                'suggestion': "Remove console.log statements before production deployment",
+                'fix': lambda code: code  # No automatic fix
+            },
+            {
+                'pattern': r"document\.write\(",
+                'issue': "using document.write",
+                'suggestion': "Avoid document.write as it can overwrite the entire document",
+                'fix': lambda code: code  # No automatic fix
+            },
+            {
+                'pattern': r"setTimeout\(\s*function\s*\(\)\s*{\s*},\s*0\)",
+                'issue': "setTimeout with 0 delay",
+                'suggestion': "Consider using requestAnimationFrame instead for browser animations",
+                'fix': lambda code: code  # No automatic fix
+            }
+        ]
+        
+        self.generic_issue_detectors = [
+            {
+                'pattern': r"(.{80,})\n",
+                'issue': "lines exceeding 80 characters",
+                'suggestion': "Keep lines under 80 characters for better readability",
+                'fix': lambda code: code  # No automatic fix, requires manual line splitting
+            },
+            {
+                'pattern': r"(\/\/|\#)\s*TODO",
+                'issue': "TODO comments in code",
+                'suggestion': "Resolve TODO comments before considering code complete",
+                'fix': lambda code: code  # No automatic fix
+            },
+            {
+                'pattern': r"[^\w](\w{1,2})[^\w]",
+                'issue': "short variable names",
+                'suggestion': "Use descriptive variable names that explain their purpose",
+                'fix': lambda code: code  # No automatic fix, requires understanding context
+            }
+        ]
+    
+    def detect_language(self, code):
+        """Detect what programming language the code is written in"""
+        # Python detection
+        if "def " in code or "import " in code or "class " in code and ":" in code:
+            return "Python"
+        # JavaScript detection
+        elif "function " in code or "var " in code or "let " in code or "const " in code:
+            return "JavaScript"
+        # Unknown language
+        else:
+            return "unknown"
+    
+    def analyze_code(self, code, language):
+        """Analyze code for issues based on detected language"""
+        issues = []
+        suggestions = []
+        fix_functions = []
+        
+        # Select appropriate detectors based on language
+        if language == "Python":
+            detectors = self.python_issue_detectors + self.generic_issue_detectors
+        elif language == "JavaScript":
+            detectors = self.js_issue_detectors + self.generic_issue_detectors
+        else:
+            detectors = self.generic_issue_detectors
+        
+        # Apply each detector
+        for detector in detectors:
+            if re.search(detector['pattern'], code):
+                issues.append(detector['issue'])
+                suggestions.append(detector['suggestion'])
+                fix_functions.append(detector['fix'])
+        
+        # Check for missing newline at end of file
+        if code.count('\n') > 3 and not code.strip().endswith('\n'):
+            issues.append("missing newline at end of file")
+            suggestions.append("Add a newline at the end of the file (standard best practice)")
+            fix_functions.append(lambda code: code + '\n')
+        
+        return issues, suggestions, fix_functions
+    
+    def generate_roast(self, issues, level):
+        """Generate a roast message based on the issues found and the roast level"""
+        base_roast = random.choice(self.roast_templates[level])
+        
+        if issues:
+            if level == "Mild":
+                roast = f"{base_roast}\n\nI noticed these {len(issues)} issues that could be improved: {', '.join(issues)}."
+            elif level == "Medium":
+                roast = f"{base_roast}\n\nSpecifically, I found {len(issues)} issues that need attention: {', '.join(issues)}."
+            else:  # Savage
+                roast = f"{base_roast}\n\nThis masterpiece of chaos has {len(issues)} issues: {', '.join(issues)}."
+        else:
+            if level == "Mild":
+                roast = f"{base_roast}\n\nYour code is actually pretty clean, but there are always ways to improve."
+            elif level == "Medium":
+                roast = f"{base_roast}\n\nSurprisingly, your code doesn't have major issues, but let's not celebrate too early."
+            else:  # Savage
+                roast = f"{base_roast}\n\nI was ready to demolish this code, but it's... acceptable. Don't get used to compliments."
+        
+        return roast
+    
+    def fix_code(self, code, fix_functions):
+        """Apply all fix functions to the code"""
+        fixed_code = code
+        for fix_func in fix_functions:
+            fixed_code = fix_func(fixed_code)
+        return fixed_code
+    
+    def generate_explanation(self, issues, suggestions, language):
+        """Generate an explanation of the issues and suggestions"""
+        explanation = "Here's what I found and improved:\n\n"
+        
+        if issues:
+            for i, (issue, suggestion) in enumerate(zip(issues, suggestions)):
+                explanation += f"{i+1}. **{issue.capitalize()}**: {suggestion}\n"
+        else:
+            explanation += "- Made minor formatting improvements for better readability\n"
+        
+        if language != "unknown":
+            explanation += f"\nYour code appears to be written in {language}. "
+        
+        explanation += "\nWriting clean, consistent code helps with maintainability and reduces bugs!"
+        
+        return explanation
+    
+    def roast_code(self, code, roast_level):
+        """Main function to analyze, roast and fix code"""
+        if not code.strip():
+            return "Please enter some code to roast.", "No code provided.", "Nothing to fix."
+        
+        try:
+            # Detect language
+            language = self.detect_language(code)
+            logger.info(f"Detected language: {language}")
+            
+            # Analyze code
+            issues, suggestions, fix_functions = self.analyze_code(code, language)
+            logger.info(f"Found {len(issues)} issues")
+            
+            # Generate roast
+            roast = self.generate_roast(issues, roast_level)
+            
+            # Fix code
+            fixed_code = self.fix_code(code, fix_functions)
+            
+            # Generate explanation
+            explanation = self.generate_explanation(issues, suggestions, language)
+            
+            return roast, fixed_code, explanation
+            
+        except Exception as e:
+            logger.error(f"Error analyzing code: {str(e)}")
+            return (
+                f"Oops! Something went wrong while roasting your code: {str(e)}",
+                code,
+                "Error generating explanation."
+            )
+
+# ======= HUGGING FACE API INTEGRATION ========
+def call_huggingface_api(code, roast_level, api_key, model_name):
+    if not code.strip():
+        return "Please enter some code to roast.", "No code provided.", "Nothing to fix."
+    
+    if not api_key.strip():
+        return "Please enter a valid Hugging Face API key.", code, "API key is required."
+    
+    try:
+        logger.info(f"Calling Hugging Face API with model: {model_name}")
+        
+        # Create different prompts based on roast level
+        roast_level_descriptions = {
+            "Mild": "gentle but humorous",
+            "Medium": "moderately sarcastic and pointed",
+            "Savage": "brutally honest and hilariously critical"
+        }
+        
+        # Better prompt format with less chance of format confusion
+        prompt = f"""You're a senior software engineer reviewing this code:
+
+```
+{code}
+```
+
+Respond with THREE separate sections:
+
+1. ROAST: Give a {roast_level_descriptions[roast_level]} code review. Be humorous but point out real issues.
+
+2. FIXED_CODE: Provide an improved version of the code.
+
+3. EXPLANATION: Explain what was improved and why it matters.
+
+Start each section with the heading exactly as shown above.
+"""
+        
+        # API URL based on selected model
+        API_URL = f"https://api-inference.huggingface.co/models/{model_name}"
+        
+        # Set up the headers with API key
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        # Set up the payload
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 2048,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "top_k": 50,
+                "repetition_penalty": 1.2,
+                "stop": ["<|endoftext|>", "</s>"]
+            }
+        }
+        
+        # Make the API call
+        response = requests.post(API_URL, headers=headers, json=payload)
+        
+        # Check if the request was successful
+        if response.status_code != 200:
+            logger.error(f"API Error: {response.status_code} - {response.text}")
+            return f"Error: {response.status_code} - {response.text}", code, "API call failed."
+        
+        # Extract the response text
+        try:
+            response_text = response.json()[0]["generated_text"]
+            logger.info(f"Raw API response received with length: {len(response_text)}")
+            
+            # Remove the original prompt if it's included in the response
+            if prompt in response_text:
+                response_text = response_text.replace(prompt, "")
+            
+            # Now extract each section using regex
+            roast_match = re.search(r"ROAST:(.*?)(?=FIXED_CODE:|$)", response_text, re.DOTALL)
+            code_match = re.search(r"FIXED_CODE:(.*?)(?=EXPLANATION:|$)", response_text, re.DOTALL)
+            explanation_match = re.search(r"EXPLANATION:(.*?)$", response_text, re.DOTALL)
+            
+            # Extract content from matches
+            roast = roast_match.group(1).strip() if roast_match else "Failed to generate roast."
+            
+            # For the code section, also look for code blocks
+            if code_match:
+                code_section = code_match.group(1).strip()
+                # Try to extract code between triple backticks if present
+                code_block_match = re.search(r"```(?:\w+)?\n(.*?)```", code_section, re.DOTALL)
+                if code_block_match:
+                    fixed_code = code_block_match.group(1).strip()
+                else:
+                    # If no code blocks, use the whole section
+                    fixed_code = code_section
+            else:
+                fixed_code = "Failed to generate fixed code."
+            
+            explanation = explanation_match.group(1).strip() if explanation_match else "Failed to generate explanation."
+            
+            # If sections are still missing or empty, provide default messages
+            if not roast or roast == "":
+                roast = "The model didn't generate a proper roast. Try again or use local mode."
+            
+            if not fixed_code or fixed_code == "":
+                fixed_code = code
+            
+            if not explanation or explanation == "":
+                explanation = "The model didn't generate a proper explanation. Try again or use local mode."
+            
+            logger.info("Successfully parsed response from Hugging Face API")
+            return roast, fixed_code, explanation
+            
+        except Exception as e:
+            logger.error(f"Error parsing API response: {e}")
+            logger.error(f"Response content: {response.content[:500]}")  # Log first 500 chars
+            return "Error parsing API response", code, f"Error details: {str(e)}"
+    
+    except Exception as e:
+        logger.error(f"Error calling Hugging Face API: {str(e)}")
+        return (
+            f"Oops! Something went wrong while roasting your code: {str(e)}",
+            code,
+            "Error generating explanation."
+        )
+
+# ======= MAIN ROASTING FUNCTION ========
+def roast_code(code, roast_level, use_api, api_key="", model_choice="Mistral-7B"):
+    # Map model choice to actual model name
+    model_map = {
+        "Mistral-7B": "mistralai/Mistral-7B-Instruct-v0.2",
+        "Falcon-7B": "tiiuae/falcon-7b-instruct",
+        "Llama-2-7B": "meta-llama/Llama-2-7b-chat-hf",
+        "CodeLlama-7B": "codellama/CodeLlama-7b-instruct-hf"
+    }
+    
+    model_name = model_map.get(model_choice, model_map["Mistral-7B"])
+    
+    if use_api and api_key.strip():
+        # Use the API with specified model
+        logger.info(f"Using API with model: {model_name}")
+        return call_huggingface_api(code, roast_level, api_key, model_name)
+    else:
+        # Use the local analysis
+        logger.info("Using local code analysis")
+        roaster = CodeRoaster()
+        return roaster.roast_code(code, roast_level)
+
+# ======= GRADIO INTERFACE ========
+def create_interface():
+    with gr.Blocks(title="AI Roast My Code") as app:
+        gr.Markdown("# 🔥 AI Roast My Code 🔥")
+        gr.Markdown("Let our AI roast your code, fix it, and teach you - all while making you laugh!")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                code_input = gr.Textbox(
+                    label="Your Code",
+                    lines=15
+                )
+            with gr.Column(scale=1):
+                roast_level = gr.Radio(
+                    choices=["Mild", "Medium", "Savage"],
+                    label="Roast Level",
+                    value="Medium"
+                )
+                
+                use_api = gr.Checkbox(label="Use Hugging Face API", value=True)
+                
+                with gr.Group(visible=True) as api_settings:
+                    api_key = gr.Textbox(
+                        label="Hugging Face API Key", 
+                        type="password",
+                        value=os.environ.get("HF_API_KEY", "")
+                    )
+                    
+                    model_choice = gr.Dropdown(
+                        choices=["Mistral-7B", "Falcon-7B", "Llama-2-7B", "CodeLlama-7B"],
+                        label="Model",
+                        value="Mistral-7B",
+                        info="Select which LLM to use for code analysis"
+                    )
+                
+                submit_btn = gr.Button("🔥 Roast My Code!", variant="primary")
+        
+        # Function to toggle API settings visibility
+        def toggle_api_settings(use_api):
+            return gr.Group.update(visible=use_api)
+        
+        use_api.change(fn=toggle_api_settings, inputs=use_api, outputs=api_settings)
+        
+        # Output Sections
+        with gr.Row():
+            loading_indicator = gr.Textbox(label="Status", value="")
+            
+        with gr.Tab("Roast 🔥"):
+            roast_output = gr.Textbox(label="Roast", lines=5)
+            
+        with gr.Tab("Fixed Code ✅"):
+            fixed_code_output = gr.Textbox(label="Fixed Code", lines=10)
+            
+        with gr.Tab("Explanation 📝"):
+            explanation_output = gr.Textbox(label="Explanation", lines=5)
+        
+        # Example code
+        example_python_code = '''def calculate_fibonacci(n):
+    # This function calculates the fibonacci sequence
+    result = []
+    a, b = 0, 1
+    for i in range(0, n):
+        result.append(a)
+        a, b = b, a + b
+    
+    return result
+
+if **name** == "__main__":
+    print("Fibonacci Sequence:")
+    print(calculate_fibonacci(10))
+'''
+
+        # Event handlers
+        def load_example():
+            return example_python_code
+            
+        def clear_inputs():
+            return ""
+        
+        def show_loading():
+            return "⏳ AI is analyzing your code and preparing a roast. This may take a few moments..."
+        
+        def hide_loading():
+            return "✅ Roast complete! Check the tabs below for results."
+        
+        # Set up buttons for examples and clearing
+        with gr.Row():
+            example_btn = gr.Button("Load Example Code")
+            clear_btn = gr.Button("Clear")
+            
+        example_btn.click(fn=load_example, outputs=code_input)
+        clear_btn.click(fn=clear_inputs, outputs=code_input)
+        
+        # Main submit button with loading state
+        submit_btn.click(
+            fn=show_loading,
+            outputs=loading_indicator
+        ).then(
+            fn=roast_code,
+            inputs=[code_input, roast_level, use_api, api_key, model_choice],
+            outputs=[roast_output, fixed_code_output, explanation_output]
+        ).then(
+            fn=hide_loading,
+            outputs=loading_indicator
+        )
+        
+        # About Section
+        gr.Markdown("""
+        ### 🤖 How It Works
+        
+        "AI Roast My Code" can work in two modes:
+        
+        1. **API Mode**: Uses the Hugging Face API with various models to provide advanced code analysis
+           - Multiple model options including Mistral, Falcon, Llama-2, and CodeLlama
+           - Requires a Hugging Face API key
+        
+        2. **Local Mode**: Uses built-in pattern matching for basic code analysis (no API needed)
+           - Works completely offline
+           - No API key required
+           - Detects common issues in Python and JavaScript
+        
+        The app will:
+        1. **Analyze** your code for problems, anti-patterns, and style issues
+        2. **Roast** it with humor that ranges from gentle to savage (you choose!)
+        3. **Fix** the issues and provide an improved version
+        4. **Explain** what was wrong and how it was improved
+        
+        ### 📝 Note
+        
+        - For educational purposes only - always review generated code before using it
+        """)
+    
+    return app
+
+# Main function
+def main():
+    try:
+        logger.info("Starting AI Roast My Code...")
+        
+        # Create the interface
+        app = create_interface()
+        
+        # Launch the app
+        logger.info("Launching Gradio interface...")
+        app.launch(share=True)
+    except Exception as e:
+        logger.error(f"Error launching application: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    main()