Update app.py

app.py

@@ -1,16 +1,30 @@
 import gradio as gr
 from openai import OpenAI
 import os
-from typing import List, Tuple
 import time
+from typing import List, Tuple, Generator
 
-# Initialize OpenAI client with Hugging Face endpoint
+
+import os
+from openai import OpenAI
+
+# Load API key from environment
+HF_API_TOKEN = os.getenv("HF_TOKEN")
+if not HF_API_TOKEN:
+    raise ValueError("Missing HF_API_TOKEN environment variable")
+
+# Initialize client with environment-based config
 client = OpenAI(
     base_url="https://api-inference.huggingface.co/v1/",
-    api_key=os.getenv("HF_API_TOKEN")
+    api_key=HF_API_TOKEN  # Uses env variable
 )
 
+# Constants
 MODEL_ID = "Qwen/Qwen2.5-Coder-32B-Instruct"
+HF_API_TOKEN = os.getenv("HF_TOKEN")
+DEFAULT_TEMPERATURE = 0.2
+MAX_TOKENS_LIMIT = 8192
+STREAM_DELAY = 0.015
 
 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.
@@ -70,8 +84,7 @@ A concise summary of the feature or inferred functionality based on the user inp
 Manual Test Cases:
 
 vbnet
-Copy
-Edit
+```
 TC001: Verify successful login with valid credentials  
 Precondition(s): The user must have a valid account.  
 Steps:  
@@ -81,9 +94,10 @@ Steps:
 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', () => {
@@ -118,100 +132,145 @@ test.describe('Login Feature Tests', () => {
     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!
 
 """
 
-CSS = """
-.gr-chatbot { min-height: 500px; border-radius: 15px; }
-.special-tag { color: #2ecc71; font-weight: 600; }
-footer { display: none !important; }
-"""
+# HTML formatting tags to emphasize
+FORMATTING_TAGS = [
+    "[Understand]", "[Plan]", "[Conclude]", 
+    "[Reason]", "[Verify]", "[Capabilities]",
+    "[Response Guidelines]"
+]
+
+def initialize_client() -> OpenAI:
+    """Initialize and return the OpenAI client with Hugging Face configuration."""
+    return OpenAI(
+        base_url="https://api-inference.huggingface.co/v1/",
+        api_key=HF_API_TOKEN
+    )
 
 def format_response(text: str) -> str:
-    """Format the response by adding HTML styling to special tags."""
-    return text.replace("[Understand]", '\n<strong class="special-tag">[Understand]</strong>\n') \
-              .replace("[Plan]", '\n<strong class="special-tag">[Plan]</strong>\n') \
-              .replace("[Conclude]", '\n<strong class="special-tag">[Conclude]</strong>\n') \
-              .replace("[Reason]", '\n<strong class="special-tag">[Reason]</strong>\n') \
-              .replace("[Verify]", '\n<strong class="special-tag">[Verify]</strong>\n')
+    """Apply HTML formatting to special tags in the response text."""
+    for tag in FORMATTING_TAGS:
+        text = text.replace(
+            tag, 
+            f'<strong class="special-tag">{tag}</strong>'
+        )
+    return text
 
-def generate_response(
-    message: str,
+def construct_messages(
+    user_input: str,
     chat_history: List[Tuple[str, str]],
-    system_prompt: str,
-    temperature: float,
-    max_tokens: int
-):
-    """Generate a response using the OpenAI-compatible Hugging Face API."""
-    # Create conversation history
+    system_prompt: str
+) -> List[dict]:
+    """Construct the message history for the API request."""
     messages = [{"role": "system", "content": system_prompt}]
+    
     for user_msg, bot_msg in chat_history:
         messages.extend([
             {"role": "user", "content": user_msg},
             {"role": "assistant", "content": bot_msg}
         ])
-    messages.append({"role": "user", "content": message})
+    
+    messages.append({"role": "user", "content": user_input})
+    return messages
+
+def handle_api_error(e: Exception) -> str:
+    """Generate user-friendly error messages for different error types."""
+    error_type = type(e).__name__
+    if "Authentication" in str(e):
+        return "🔒 Authentication Error: Check your API token"
+    elif "Timeout" in str(e):
+        return "⏳ Request Timeout: Try again later"
+    return f"⚠️ Error ({error_type}): {str(e)}"
 
-    # Create new chat history with empty response
+def generate_response(
+    message: str,
+    chat_history: List[Tuple[str, str]],
+    system_prompt: str,
+    temperature: float,
+    max_tokens: int
+) -> Generator[List[Tuple[str, str]], None, None]:
+    """Generate streaming response using Hugging Face inference API."""
+    client = initialize_client()
     new_history = chat_history + [(message, "")]
     partial_message = ""
-
+    
     try:
-        # Create streaming completion
+        messages = construct_messages(message, chat_history, system_prompt)
+        
         stream = client.chat.completions.create(
             model=MODEL_ID,
             messages=messages,
             temperature=temperature,
-            max_tokens=max_tokens,
+            max_tokens=min(max_tokens, MAX_TOKENS_LIMIT),
             stream=True
         )
 
-        # Process the stream
         for chunk in stream:
-            if chunk.choices[0].delta.content is not None:
+            if chunk.choices[0].delta.content:
                 partial_message += chunk.choices[0].delta.content
-                formatted = format_response(partial_message)
-                new_history[-1] = (message, formatted + "▌")
+                formatted_response = format_response(partial_message + "▌")
+                new_history[-1] = (message, formatted_response)
                 yield new_history
-                time.sleep(0.01)  # Small delay to prevent UI lag
+                time.sleep(STREAM_DELAY)
 
-        # 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:
-    gr.Markdown("""
-    <h1 align="center">🧠 AI Reasoning Assistant</h1>
-    <p align="center">Ask me Hard questions</p>
-    """)
+        error_msg = handle_api_error(e)
+        new_history[-1] = (message, error_msg)
     
-    chatbot = gr.Chatbot(label="Conversation", elem_id="chatbot")
-    msg = gr.Textbox(label="Your Question", placeholder="Type your question...")
-    
-    with gr.Accordion("⚙️ Settings", open=False):
-        system_prompt = gr.TextArea(value=DEFAULT_SYSTEM_PROMPT, label="System Instructions")
-        temperature = gr.Slider(0, 1, value=0.5, label="Creativity")
-        max_tokens = gr.Slider(128, 4096, value=2048, label="Max Response Length")
+    yield new_history
 
-    clear = gr.Button("Clear History")
+def create_interface() -> gr.Blocks:
+    """Create and configure the Gradio interface."""
+    css = """
+    .gr-chatbot { min-height: 500px; border-radius: 15px; }
+    .special-tag { color: #2ecc71; font-weight: 600; }
+    footer { visibility: hidden; }
+    """
     
-    msg.submit(
-        generate_response,
-        [msg, chatbot, system_prompt, temperature, max_tokens],
-        [chatbot],
-        show_progress=True
-    )
-    clear.click(lambda: None, None, chatbot, queue=False)
+    with gr.Blocks(css=css, theme=gr.themes.Soft()) as interface:
+        gr.Markdown("""
+        # 🧠 AI Test Engineering Assistant
+        ## Specialized in Automated Testing Strategies
+        """)
+        
+        chatbot = gr.Chatbot(label="Testing Discussion", elem_classes="gr-chatbot")
+        user_input = gr.Textbox(label="Feature Description", placeholder="Describe feature or paste branch name...")
+        
+        with gr.Accordion("Engine Parameters", open=False):
+            system_prompt = gr.TextArea(value=DEFAULT_SYSTEM_PROMPT, label="System Instructions")
+            temperature = gr.Slider(0, 1, value=DEFAULT_TEMPERATURE, label="Creativity Level")
+            max_tokens = gr.Slider(128, MAX_TOKENS_LIMIT, value=2048, label="Response Length")
+        
+        controls = gr.Row():
+            clear_btn = gr.Button("🧹 Clear History")
+            submit_btn = gr.Button("🚀 Generate Tests")
+        
+        user_input.submit(
+            generate_response,
+            [user_input, chatbot, system_prompt, temperature, max_tokens],
+            [chatbot]
+        )
+        
+        submit_btn.click(
+            generate_response,
+            [user_input, chatbot, system_prompt, temperature, max_tokens],
+            [chatbot]
+        )
+        
+        clear_btn.click(lambda: [], None, chatbot)
+
+    return interface
 
 if __name__ == "__main__":
-    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()
+    if not HF_API_TOKEN:
+        raise ValueError("HF_API_TOKEN environment variable not set")
+    
+    interface = create_interface()
+    interface.launch(server_port=7860, show_error=True)