Update app.py

app.py

@@ -1,220 +1,136 @@
 import gradio as gr
+import os
+from openai import OpenAI
 import time
+import markdown
 
-# Try importing OpenAI with error handling
-try:
-    from openai import OpenAI
-except ImportError:
-    print("OpenAI package not installed. Installing now...")
-    import subprocess
-    import sys
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "openai"])
-    from openai import OpenAI
-
-def test_api_connection(api_key):
-    """Test the API connection and return a status message"""
-    if not api_key or api_key.strip() == "":
-        return False, "API key is required"
+def solve_competitive_problem(problem_statement, language_choice, api_key):
+    """
+    Generate a solution for a competitive programming problem
     
-    try:
-        client = OpenAI(
-            base_url="https://openrouter.ai/api/v1",
-            api_key=api_key.strip(),
-        )
-        # Simple request to test connection
-        client.models.list()
-        return True, "API connection successful"
-    except Exception as e:
-        return False, f"API connection failed: {str(e)}"
-
-def generate_solution(api_key, problem_statement, progress=gr.Progress()):
-    """Generate solution with progress updates"""
-    progress(0, desc="Starting...")
-    
-    # Input validation
-    if not api_key or api_key.strip() == "":
-        return "Error: OpenRouter API key is required"
+    Args:
+        problem_statement (str): The problem statement
+        language_choice (str): Programming language for the solution
+        api_key (str): OpenRouter API key
     
-    if not problem_statement or problem_statement.strip() == "":
-        return "Error: Please provide a problem statement"
+    Returns:
+        str: Step-by-step solution with code
+    """
+    if not api_key.strip():
+        return "Error: Please provide your OpenRouter API key."
     
-    progress(0.1, desc="Validating API key...")
-    # Test API connection first
-    success, message = test_api_connection(api_key)
-    if not success:
-        return f"Error: {message}"
+    if not problem_statement.strip():
+        return "Error: Please provide a problem statement."
     
-    progress(0.3, desc="Sending request to AI model...")
     try:
+        # Initialize OpenAI client with OpenRouter base URL
         client = OpenAI(
             base_url="https://openrouter.ai/api/v1",
-            api_key=api_key.strip(),
+            api_key=api_key,
         )
         
-        progress(0.5, desc="Generating solution...")
+        # Create prompt with language preference
+        prompt = f"""
+You are an expert competitive programmer. Analyze the following problem and provide a step-by-step solution with explanations and code in {language_choice}.
+
+Problem:
+{problem_statement}
+
+Your response should include:
+1. Problem Analysis: Break down the problem statement and identify the key challenges
+2. Approach: Describe your approach to solve the problem and why it's optimal
+3. Algorithm: Explain the algorithm you'll use with time and space complexity analysis
+4. Implementation: Write clean, efficient, and well-commented {language_choice} code
+5. Testing: Explain how to test the solution with example inputs/outputs
+        """
+        
+        # Call the model
         completion = client.chat.completions.create(
+            extra_headers={
+                "HTTP-Referer": "https://competitive-programming-assistant.app",
+                "X-Title": "Competitive Programming Assistant",
+            },
             model="open-r1/olympiccoder-7b:free",
             messages=[
-                {
-                    "role": "system",
-                    "content": "You are a competitive programming expert. Provide a correct solution with clear reasoning. First output the code, then explain the approach."
-                },
                 {
                     "role": "user",
-                    "content": f"Solve this problem:\n{problem_statement}"
+                    "content": prompt
                 }
             ],
-            temperature=0.3,
-            max_tokens=2048
+            temperature=0.7,
+            stream=False
         )
         
-        progress(0.8, desc="Processing response...")
-        response = completion.choices[0].message.content
-        
-        progress(0.9, desc="Formatting output...")
-        formatted_response = format_response(response)
+        solution = completion.choices[0].message.content
+        return solution
         
-        progress(1.0, desc="Done!")
-        return formatted_response
-    
     except Exception as e:
-        error_message = str(e)
-        print(f"Error occurred: {error_message}")
-        return f"Error: {error_message}"
+        return f"Error: {str(e)}"
 
-def format_response(response):
-    """Format the AI response into markdown with code blocks"""
-    if not response:
-        return "Error: Received empty response from AI model"
-    
-    formatted = []
-    lines = response.split('\n')
-    
-    # Find code blocks
-    in_code = False
-    code_blocks = []
-    current_block = []
-    
-    for line in lines:
-        if line.strip().startswith('```'):
-            if in_code:
-                code_blocks.append(current_block)
-                current_block = []
-            else:
-                current_block = []
-            in_code = not in_code
-            continue
-        
-        if in_code:
-            current_block.append(line)
-    
-    # Handle unclosed code block
-    if in_code and current_block:
-        code_blocks.append(current_block)
+# Create a Gradio interface
+with gr.Blocks(title="Competitive Programming Assistant", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🏆 Competitive Programming Assistant
     
-    # Process code blocks and explanations
-    processed_response = response
+    Upload a problem statement from Codeforces, LeetCode, or any competitive programming platform to get:
+    - Step-by-step analysis
+    - Optimal solution approach
+    - Complete code implementation
+    - Time and space complexity analysis
     
-    # Replace each code block with properly formatted markdown
-    for i, block in enumerate(code_blocks):
-        # Skip language identifier if present
-        if block and any(block[0].strip().lower() == lang for lang in ["python", "java", "c++", "cpp", "javascript"]):
-            code_content = '\n'.join(block[1:])
-            lang = block[0].strip().lower()
-        else:
-            code_content = '\n'.join(block)
-            lang = "python"  # Default to Python
-        
-        # Create search pattern for the original block
-        if i < len(code_blocks) - 1 or not in_code:
-            block_text = '```' + '\n' + '\n'.join(block) + '\n' + '```'
-        else:
-            block_text = '```' + '\n' + '\n'.join(block)
-        
-        # Replace with properly formatted block
-        formatted_block = f"```{lang}\n{code_content}\n```"
-        processed_response = processed_response.replace(block_text, formatted_block)
-    
-    return processed_response
-
-# Define the Gradio interface
-with gr.Blocks(title="Competitive Programming Assistant", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🏆 Competitive Programming Assistant")
-    gr.Markdown("Powered by OlympicCoder-7B via OpenRouter AI")
+    Powered by the OlympicCoder model.
+    """)
     
     with gr.Row():
-        with gr.Column():
-            api_key = gr.Textbox(
+        with gr.Column(scale=2):
+            api_key_input = gr.Textbox(
+                placeholder="Enter your OpenRouter API key here",
                 label="OpenRouter API Key",
-                type="password",
-                placeholder="Enter your API key here...",
-                value=""
+                type="password"
             )
             
-            test_btn = gr.Button("Test API Connection", variant="secondary")
-            api_status = gr.Textbox(label="API Status", interactive=False)
+            problem_input = gr.Textbox(
+                placeholder="Paste your competitive programming problem statement here...",
+                label="Problem Statement",
+                lines=10
+            )
             
-            test_btn.click(
-                fn=test_api_connection,
-                inputs=[api_key],
-                outputs=[gr.Checkbox(visible=False), api_status]
+            language = gr.Dropdown(
+                choices=["Python", "C++", "Java", "JavaScript"],
+                value="Python",
+                label="Programming Language"
+            )
+            
+            submit_btn = gr.Button("Generate Solution", variant="primary")
+        
+        with gr.Column(scale=3):
+            solution_output = gr.Markdown(
+                label="Generated Solution"
             )
     
-    with gr.Row():
-        problem_input = gr.Textbox(
-            label="Problem Statement",
-            lines=5,
-            placeholder="Paste your programming problem here..."
-        )
-    
-    submit_btn = gr.Button("Generate Solution", variant="primary", size="lg")
-    
-    # Add a status indicator
-    status = gr.Markdown("Ready to generate solutions")
-    
-    # Output area
-    solution_output = gr.Markdown(label="Solution")
-    
-    # Example problems
-    gr.Examples(
-        examples=[
-            [
-                "Given an array of integers, find two numbers such that they add up to a specific target number."
-            ],
-            [
-                "Implement a function to calculate the minimum number of operations required to transform one string into another using only insertion, deletion, and substitution."
-            ]
-        ],
-        inputs=[problem_input]
-    )
-    
-    # Set up event handlers with additional status updates
-    def on_submit_click(api_key, problem):
-        return "Generating solution... Please wait."
+    with gr.Accordion("About", open=False):
+        gr.Markdown("""
+        ### How to use this app:
+        
+        1. Enter your OpenRouter API key (get one at [openrouter.ai](https://openrouter.ai))
+        2. Paste the complete problem statement
+        3. Select your preferred programming language
+        4. Click "Generate Solution"
+        
+        ### Tips for best results:
+        
+        - Include the entire problem, including input/output formats and constraints
+        - Make sure to include example inputs and outputs
+        - For complex problems, consider adding clarifying notes
+        """)
     
+    # Handle form submission
     submit_btn.click(
-        fn=on_submit_click,
-        inputs=[api_key, problem_input],
-        outputs=[status],
-        queue=False
-    ).then(
-        fn=generate_solution,
-        inputs=[api_key, problem_input],
-        outputs=[solution_output],
-        queue=True
-    ).success(
-        fn=lambda: "Solution generated successfully!",
-        inputs=None,
-        outputs=[status]
-    ).error(
-        fn=lambda: "An error occurred. Please check your inputs and try again.",
-        inputs=None,
-        outputs=[status]
+        solve_competitive_problem,
+        inputs=[problem_input, language, api_key_input],
+        outputs=solution_output
     )
 
+# Launch the app
 if __name__ == "__main__":
-    try:
-        print("Starting Competitive Programming Assistant...")
-        app.launch(server_port=7860, share=True, debug=True)
-    except Exception as e:
-        print(f"Error launching app: {str(e)}")
+    app.launch()