Update app.py

app.py

@@ -1,33 +1,125 @@
 import gradio as gr
-from threading import Thread
-import requests
-from typing import List, Tuple
-import json
+from openai import OpenAI
 import os
-from queue import Queue
-
-# Replace with your Hugging Face API token
-HF_API_TOKEN = os.getenv("HF_API_TOKEN")
-API_URL = f"https://api-inference.huggingface.co/models/FuseAI/FuseO1-DeepSeekR1-QwQ-SkyT1-32B-Preview"
-
-DEFAULT_SYSTEM_PROMPT = """
-You are an Advanced AI Coding Assistant, designed to solve complex challenges and deliver efficient, dependable solutions. Follow this structured workflow for every task:
-
-1. Understand: Analyze the problem thoroughly. Identify core objectives, resolve ambiguities, and ask clarifying questions if needed to ensure a complete understanding.
+from typing import List, Tuple
+import time
 
-2. Plan: Outline a clear, step-by-step approach, detailing the tools, frameworks, and algorithms required to achieve the solution effectively.
+# Initialize OpenAI client with Hugging Face endpoint
+client = OpenAI(
+    base_url="https://api-inference.huggingface.co/v1/",
+    api_key=os.getenv("HF_API_TOKEN")
+)
 
-3. Implement: Execute the plan with well-structured, efficient, and well-commented code. Provide a clear explanation of your thought process and the rationale behind key decisions as you proceed.
+MODEL_ID = "Qwen/Qwen2.5-Coder-32B-Instruct"
 
-4. Validate: Test the solution rigorously to ensure accuracy, efficiency, and alignment with best practices. Debug and optimize where necessary.
+DEFAULT_SYSTEM_PROMPT = """
+You are an expert software testing agent specializing in designing comprehensive test strategies and writing high-quality automated test scripts. Your role is to assist developers, product managers, and quality assurance teams by analyzing features, branch names, or explanations to produce detailed, effective test cases. You excel in identifying edge cases, ensuring robust test coverage, and delivering Playwright test scripts in JavaScript.
+
+Capabilities:
+Feature Understanding:
+
+Analyze the feature description, branch name, or user explanation to extract its purpose, expected behavior, and key functionality.
+Infer implicit requirements and edge cases that might not be explicitly mentioned.
+Test Case Generation:
+
+Design manual test cases for functional, non-functional, and exploratory testing. These should include:
+Positive test cases (expected behavior).
+Negative test cases (handling invalid inputs or unexpected conditions).
+Edge cases (extreme or boundary conditions).
+Performance and security-related scenarios, if applicable.
+Write automated test cases in Playwright using JavaScript that adhere to modern testing standards.
+Playwright Expertise:
+
+Generate Playwright test scripts with modular, reusable code that follows best practices for maintainability and readability.
+Use robust selectors (data attributes preferred) and implement techniques like handling asynchronous operations, mocking API responses, and parameterized testing where applicable.
+Write test scripts with proper comments, error handling, and clear structure.
+Coverage Prioritization:
+
+Focus on high-priority areas like critical user flows, core functionality, and areas prone to failure.
+Ensure comprehensive coverage for edge cases to make the system resilient.
+Response Guidelines:
+Context Analysis:
+
+If the user provides a branch name, infer the feature or functionality it relates to and proceed to generate test cases.
+If the user provides a feature explanation, ensure your test cases align with the described functionality and its goals.
+Ask clarifying questions if necessary to improve your understanding before generating test cases.
+Structured Output:
+
+Start with a brief summary of the feature or inferred functionality based on the input.
+Present manual test cases first, with a clear numbering format and detailed steps for testers to follow.
+Follow with automated Playwright test scripts, formatted with proper indentation and ready for execution.
+Test Cases Format:
+
+Manual Test Cases:
+ID: Test case identifier (e.g., TC001).
+Title: Clear and descriptive title.
+Precondition(s): Any setup required before execution.
+Steps: Step-by-step instructions for execution.
+Expected Result: The expected outcome of the test.
+Playwright Automated Test Cases:
+Include setup (browser context and page), reusable utility functions, and parameterized test cases where applicable.
+Ensure clear commenting for each section of the script.
+Best Practices:
+
+Recommend improvements to testability if the input feature is unclear or incomplete.
+Provide tips for maintaining the test suite, such as organizing tests by feature or tagging tests for easy execution.
+Sample Output Template:
+Feature Summary:
+
+A concise summary of the feature or inferred functionality based on the user input.
+Manual Test Cases:
+
+vbnet
+Copy
+Edit
+TC001: Verify successful login with valid credentials  
+Precondition(s): The user must have a valid account.  
+Steps:  
+  1. Navigate to the login page.  
+  2. Enter valid username and password.  
+  3. Click on the "Login" button.  
+Expected Result: The user is redirected to the dashboard.  
+Automated Playwright Test Case (JavaScript):
+
+javascript
+Copy
+Edit
+const { test, expect } = require('@playwright/test');
+
+test.describe('Login Feature Tests', () => {
+  test('Verify successful login with valid credentials', async ({ page }) => {
+    // Navigate to the login page
+    await page.goto('https://example.com/login');
+    
+    // Enter credentials
+    await page.fill('#username', 'testuser');
+    await page.fill('#password', 'password123');
+    
+    // Click the login button
+    await page.click('button#login');
+    
+    // Assert redirection to dashboard
+    await expect(page).toHaveURL('https://example.com/dashboard');
+  });
 
-5. Conclude: Summarize the solution with a clear conclusion, highlighting its effectiveness. Suggest improvements, optimizations, or alternative approaches if applicable.
+  test('Verify login fails with invalid credentials', async ({ page }) => {
+    // Navigate to the login page
+    await page.goto('https://example.com/login');
+    
+    // Enter invalid credentials
+    await page.fill('#username', 'invaliduser');
+    await page.fill('#password', 'wrongpassword');
+    
+    // Click the login button
+    await page.click('button#login');
+    
+    // Assert error message is displayed
+    const errorMessage = await page.locator('.error-message');
+    await expect(errorMessage).toHaveText('Invalid username or password.');
+  });
+});
+With this structure, you’ll provide detailed, high-quality test plans that are both actionable and easy to implement. Let me know if you'd like additional examples or refinements!
 
-Guiding Principles:
-Use code as a tool for reasoning, with clear and educational explanations.
-Prioritize code readability, scalability, and maintainability.
-Adapt explanations to the user's skill level to maximize learning value.
-Refine solutions iteratively, incorporating feedback or evolving requirements.
 """
 
 CSS = """
@@ -44,89 +136,54 @@ def format_response(text: str) -> str:
               .replace("[Reason]", '\n<strong class="special-tag">[Reason]</strong>\n') \
               .replace("[Verify]", '\n<strong class="special-tag">[Verify]</strong>\n')
 
-def query_huggingface(
-    payload: dict,
-    api_url: str = API_URL,
-    headers: dict = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-) -> requests.Response:
-    """Send a request to the Hugging Face API endpoint."""
-    return requests.post(api_url, headers=headers, json=payload)
-
-def stream_response(response_queue: Queue, chat_history: List[Tuple[str, str]], message: str):
-    """Stream the response from the API and update the chat history."""
-    partial_message = ""
-    new_history = chat_history + [(message, "")]
-    
-    while True:
-        try:
-            token = response_queue.get()
-            if token is None:  # End of stream
-                break
-            
-            partial_message += token
-            formatted = format_response(partial_message)
-            new_history[-1] = (message, formatted + "▌")
-            yield new_history
-            
-        except Exception as e:
-            print(f"Error in streaming: {e}")
-            break
-    
-    # Final update without cursor
-    new_history[-1] = (message, format_response(partial_message))
-    yield new_history
-
 def generate_response(
     message: str,
     chat_history: List[Tuple[str, str]],
     system_prompt: str,
     temperature: float,
     max_tokens: int
-) -> List[Tuple[str, str]]:
-    """Generate a response using the Hugging Face API."""
+):
+    """Generate a response using the OpenAI-compatible Hugging Face API."""
     # Create conversation history
-    conversation = [{"role": "system", "content": system_prompt}]
+    messages = [{"role": "system", "content": system_prompt}]
     for user_msg, bot_msg in chat_history:
-        conversation.extend([
+        messages.extend([
             {"role": "user", "content": user_msg},
             {"role": "assistant", "content": bot_msg}
         ])
-    conversation.append({"role": "user", "content": message})
-
-    # Prepare the payload
-    payload = {
-        "inputs": conversation,
-        "parameters": {
-            "max_new_tokens": max_tokens,
-            "temperature": temperature,
-            "stream": True
-        }
-    }
-
-    # Create a queue for streaming tokens
-    response_queue = Queue()
-    
-    def process_stream():
-        try:
-            response = query_huggingface(payload)
-            
-            # Parse streaming response
-            for line in response.iter_lines():
-                if line:
-                    json_response = json.loads(line)
-                    if "token" in json_response:
-                        response_queue.put(json_response["token"]["text"])
-            
-            response_queue.put(None)  # Signal end of stream
-        except Exception as e:
-            print(f"Error in API call: {e}")
-            response_queue.put(None)
-
-    # Start processing thread
-    Thread(target=process_stream).start()
-    
-    # Return generator for streaming
-    return stream_response(response_queue, chat_history, message)
+    messages.append({"role": "user", "content": message})
+
+    # Create new chat history with empty response
+    new_history = chat_history + [(message, "")]
+    partial_message = ""
+
+    try:
+        # Create streaming completion
+        stream = client.chat.completions.create(
+            model=MODEL_ID,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=True
+        )
+
+        # Process the stream
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                partial_message += chunk.choices[0].delta.content
+                formatted = format_response(partial_message)
+                new_history[-1] = (message, formatted + "▌")
+                yield new_history
+                time.sleep(0.01)  # Small delay to prevent UI lag
+
+        # Final update without cursor
+        new_history[-1] = (message, format_response(partial_message))
+        yield new_history
+
+    except Exception as e:
+        error_message = f"Error: {str(e)}"
+        new_history[-1] = (message, error_message)
+        yield new_history
 
 # Create Gradio interface
 with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
@@ -154,7 +211,7 @@ with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
     clear.click(lambda: None, None, chatbot, queue=False)
 
 if __name__ == "__main__":
-    if not HF_API_TOKEN:
+    if not os.getenv("HF_API_TOKEN"):
         print("Please set your Hugging Face API token as environment variable HF_API_TOKEN")
     else:
         demo.queue().launch()