Update app.py

app.py

@@ -6,9 +6,14 @@ from transformers import pipeline
 from sentence_transformers import SentenceTransformer, util
 import logging
 
-# Enable detailed logging
+# Configure logging for detailed insights
 logging.basicConfig(level=logging.INFO)
 
+# Constants for enhanced organization
+GITHUB_API_BASE_URL = "https://api.github.com/repos"
+DEFAULT_MODEL = "microsoft/CodeBERT-base"  # Robust default model selection
+MAX_RELATED_ISSUES = 3 
+
 # Hugging Face Inference Client
 client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
@@ -18,24 +23,33 @@ similarity_model = SentenceTransformer('all-mpnet-base-v2')
 ### Function to analyze issues and provide solutions
 def analyze_issues(issue_text: str, model_name: str, severity: str = None, programming_language: str = None) -> str:
     """
-    Analyze issues and provide solutions.
+    Analyzes issues and provides comprehensive solutions using a specified language model.
+
     Args:
-    issue_text (str): The issue text.
-    model_name (str): The model name.
-    severity (str, optional): The severity of the issue. Defaults to None.
-    programming_language (str, optional): The programming language. Defaults to None.
+        issue_text (str): The detailed description of the issue.
+        model_name (str): The name of the language model to use for analysis.
+        severity (str, optional): The severity level of the issue (e.g., "Critical", "Major"). Defaults to None.
+        programming_language (str, optional): The programming language relevant to the issue. Defaults to None.
+
     Returns:
-    str: The analyzed issue and solution.
+        str: A structured analysis of the issue, including problem summary, root cause, solution options, 
+             recommended solution, implementation steps, and verification steps.
     """
-    logging.info("Analyzing issue: {} with model: {}".format(issue_text, model_name))
-    prompt = """Issue: {}
-Severity: {}
-Programming Language: {}
+    logging.info(f"Analyzing issue: '{issue_text}' with model: '{model_name}'")
+
+    # Construct a detailed prompt for the language model
+    prompt = f"""Issue: {issue_text}
+Severity: {severity if severity else "Not specified"}
+Programming Language: {programming_language if programming_language else "Not specified"}
+
 Please provide a comprehensive resolution in the following format:
+
 ## Problem Summary:
 (Concise summary of the issue)
+
 ## Root Cause Analysis:
 (Possible reasons for the issue)
+
 ## Solution Options:
 1. **Option 1:** (Description)
    - Pros: (Advantages)
@@ -43,72 +57,87 @@ Please provide a comprehensive resolution in the following format:
 2. **Option 2:** (Description)
    - Pros: (Advantages)
    - Cons: (Disadvantages)
+
 ## Recommended Solution:
 (The best solution with justification)
+
 ## Implementation Steps:
 1. (Step 1)
 2. (Step 2)
 3. (Step 3)
+
 ## Verification Steps:
 1. (Step 1)
 2. (Step 2)
-""".format(issue_text, severity, programming_language)
+"""
+
     try:
-        nlp = pipeline("text-generation", model=model_name, max_length=1000)  # Increase max_length
-        logging.info("Pipeline created with model: {}".format(model_name))
+        nlp = pipeline("text-generation", model=model_name, max_length=1000)
+        logging.info(f"Pipeline created with model: '{model_name}'")
         result = nlp(prompt)
-        logging.info("Model output: {}".format(result))
-        return result[0]['generated_text']
+        logging.info(f"Model output: {result}")
+        return result[0]['generated_text'] 
     except Exception as e:
-        logging.error("Error analyzing issue with model {}: {}".format(model_name, e))
-        return "Error analyzing issue with model {}: {}".format(model_name, e)
+        logging.error(f"Error analyzing issue with model '{model_name}': {e}")
+        return f"Error analyzing issue. Please try again later." # User-friendly error message
 
 ### Function to find related issues
 def find_related_issues(issue_text: str, issues: list) -> list:
     """
-    Find related issues.
+    Finds semantically related issues from a list of issues based on the input issue text.
+
     Args:
-    issue_text (str): The issue text.
-    issues (list): The list of issues.
+        issue_text (str): The text of the issue for which to find related issues.
+        issues (list): A list of issues, where each issue is a dictionary with at least a 'title' key.
+
     Returns:
-    list: The list of related issues.
+        list: A list of tuples, each containing a related issue (dictionary) and its similarity score to the input issue.
+              The list is sorted by similarity in descending order, limited to MAX_RELATED_ISSUES.
     """
-    logging.info("Finding related issues for: {}".format(issue_text))
+    logging.info(f"Finding related issues for: '{issue_text}'")
     issue_embedding = similarity_model.encode(issue_text)
     related_issues = []
+
     for issue in issues:
         title_embedding = similarity_model.encode(issue['title'])
         similarity = util.cos_sim(issue_embedding, title_embedding)[0][0]
         related_issues.append((issue, similarity))
-    related_issues = sorted(related_issues, key=lambda x: x[1], reverse=True)
-    logging.info("Found related issues: {}".format(related_issues))
-    return related_issues[:3]  # Return top 3 most similar issues
+
+    related_issues = sorted(related_issues, key=lambda x: x[1], reverse=True)[:MAX_RELATED_ISSUES]
+    logging.info(f"Found related issues: {related_issues}")
+    return related_issues
 
 ### Function to fetch GitHub issues
 def fetch_github_issues(github_api_token: str, github_username: str, github_repository: str) -> list:
     """
-    Fetch GitHub issues.
+    Fetches issues from a specified GitHub repository using the GitHub API.
+
     Args:
-    github_api_token (str): The GitHub API token.
-    github_username (str): The GitHub username.
-    github_repository (str): The GitHub repository.
+        github_api_token (str): The user's GitHub API token for authentication.
+        github_username (str): The username of the GitHub account owning the repository.
+        github_repository (str): The name of the GitHub repository.
+
     Returns:
-    list: The list of GitHub issues.
+        list: A list of dictionaries, where each dictionary represents a GitHub issue with its details.
+
+    Raises:
+        Exception: If there's an error fetching issues from the GitHub API.
     """
-    logging.info("Fetching GitHub issues for: {}/{}".format(github_username, github_repository))
-    url = "https://api.github.com/repos/{}/{}/issues".format(github_username, github_repository)
+    logging.info(f"Fetching GitHub issues for: '{github_username}/{github_repository}'")
+    url = f"{GITHUB_API_BASE_URL}/{github_username}/{github_repository}/issues"
     headers = {
-        "Authorization": "Bearer {}".format(github_api_token),
+        "Authorization": f"Bearer {github_api_token}",
         "Accept": "application/vnd.github.v3+json"
     }
     response = requests.get(url, headers=headers)
+
     if response.status_code == 200:
         issues = response.json()
-        logging.info("Fetched issues: {}".format(issues))
+        logging.info(f"Fetched issues: {issues}")
         return issues
     else:
-        logging.error("Error fetching issues: {}".format(response.status_code))
-        raise Exception("Error fetching issues: {}".format(response.status_code))
+        logging.error(f"Error fetching issues: Status Code {response.status_code}, Response: {response.text}")
+        raise Exception(f"Error fetching GitHub issues. Please check your credentials and repository.")
 
 ### Function to handle chat responses
 def respond(
@@ -126,40 +155,41 @@ def respond(
     programming_language: str,
 ) -> str:
     """
-    Handle chat responses.
+    Handles user commands and generates responses using the selected language model.
+
     Args:
-    command (str): The command.
-    history (list[tuple[str, str]]): The chat history.
-    system_message (str): The system message.
-    max_tokens (int): The maximum number of tokens.
-    temperature (float): The temperature.
-    top_p (float): The top-p value.
-    github_api_token (str): The GitHub API token.
-    github_username (str): The GitHub username.
-    github_repository (str): The GitHub repository.
-    selected_model (str): The selected model.
-    severity (str): The severity.
-    programming_language (str): The programming language.
+        command (str): The user's command or input.
+        history (list[tuple[str, str]]): The conversation history as a list of (user, assistant) message tuples.
+        system_message (str): The initial system message defining the chatbot's persona.
+        max_tokens (int): The maximum number of tokens allowed in the generated response.
+        temperature (float): The temperature parameter controlling the randomness of the generated text.
+        top_p (float): The top-p parameter for nucleus sampling, controlling the diversity of the generated text.
+        github_api_token (str): The user's GitHub API token for authentication.
+        github_username (str): The username of the GitHub account owning the repository.
+        github_repository (str): The name of the GitHub repository.
+        selected_model (str): The name of the language model selected for generating responses.
+        severity (str): The severity level of the issue (e.g., "Critical", "Major").
+        programming_language (str): The programming language relevant to the issue.
+
     Returns:
-    str: The chat response.
+        str: The chatbot's response, generated by the selected language model or based on the command.
     """
-    global GITHUB_API_TOKEN
-    GITHUB_API_TOKEN = github_api_token
-    global issues
-    issues = []
+
+    global issues 
+    issues = [] # Reset issues for each interaction
 
     messages = [{"role": "system", "content": system_message}]
-    logging.info("System message: {}".format(system_message))
+    logging.info(f"System message: {system_message}")
 
     for user_msg, assistant_msg in history:
         if user_msg:
             messages.append({"role": "user", "content": user_msg})
-            logging.info("User message: {}".format(user_msg))
+            logging.info(f"User message: {user_msg}")
         if assistant_msg:
             messages.append({"role": "assistant", "content": assistant_msg})
-            logging.info("Assistant message: {}".format(assistant_msg))
+            logging.info(f"Assistant message: {assistant_msg}")
 
-    logging.info("Command received: {}".format(command))
+    logging.info(f"Command received: {command}")
 
     if command == "/github":
         if not github_api_token:
@@ -167,21 +197,21 @@ def respond(
         else:
             try:
                 issues = fetch_github_issues(github_api_token, github_username, github_repository)
-                issue_list = "\n".join(["{}. {}".format(i+1, issue['title']) for i, issue in enumerate(issues)])
-                return "Available GitHub Issues:\n{}\n\nEnter the issue number to analyze:".format(issue_list)
+                issue_list = "\n".join([f"{i+1}. {issue['title']}" for i, issue in enumerate(issues)])
+                return f"Available GitHub Issues:\n{issue_list}\n\nEnter the issue number to analyze:"
             except Exception as e:
-                logging.error("Error fetching GitHub issues: {}".format(e))
-                return "Error fetching GitHub issues: {}".format(e)
+                logging.error(f"Error fetching GitHub issues: {e}")
+                return "Error fetching GitHub issues. Please check your credentials and repository."
 
-  elif command == "/help":
-       help_message = """Available commands:
+    elif command == "/help":
+        help_message = """Available commands:
           - `/github`: Analyze a GitHub issue
           - `/help`: Show this help message
           - `/generate_code [code description]`: Generate code based on the description
           - `/explain_concept [concept]`: Explain a concept
           - `/write_documentation [topic]`: Write documentation for a given topic
           - `/translate_code [code] to [target language]`: Translate code to another language"""
-        return help_message  # Yield the pre-formatted help message
+        return help_message
 
     elif command.isdigit() and issues:
         try:
@@ -193,13 +223,13 @@ def respond(
             # Find and display related issues
             related_issues = find_related_issues(issue_text, issues)
             related_issue_text = "\n".join(
-                ["- {} (Similarity: {:.2f})".format(issue['title'], similarity) for issue, similarity in related_issues]
+                [f"- {issue['title']} (Similarity: {similarity:.2f})" for issue, similarity in related_issues]
             )
 
-            return "Resolution for Issue '{}':\n{}\n\nRelated Issues:\n{}".format(issue['title'], resolution, related_issue_text)
+            return f"Resolution for Issue '{issue['title']}':\n{resolution}\n\nRelated Issues:\n{related_issue_text}"
         except Exception as e:
-            logging.error("Error analyzing issue: {}".format(e))
-            return "Error analyzing issue: {}".format(e)
+            logging.error(f"Error analyzing issue: {e}")
+            return "Error analyzing issue. Please try again later."
 
     elif command.startswith("/generate_code"):
         # Extract the code description from the command
@@ -207,57 +237,57 @@ def respond(
         if not code_description:
             return "Please provide a description of the code you want to generate."
         else:
-            prompt = "Generate code for the following: {}\nProgramming Language: {}".format(code_description, programming_language)
+            prompt = f"Generate code for the following: {code_description}\nProgramming Language: {programming_language}"
             try:
                 generated_code = analyze_issues(prompt, selected_model)
-                code_output = "<pre>{}</pre>".format(generated_code)
-                return code_output  # Yield the formatted string
+                code_output = f"<pre>{generated_code}</pre>"
+                return code_output
             except Exception as e:
-                logging.error("Error generating code: {}".format(e))
-                return "Error generating code: {}".format(e)
+                logging.error(f"Error generating code: {e}")
+                return "Error generating code. Please try again later."
 
     elif command.startswith("/explain_concept"):
         concept = command.replace("/explain_concept", "").strip()
         if not concept:
             return "Please provide a concept to explain."
         else:
-            prompt = "Explain the concept of {} in detail.".format(concept)
+            prompt = f"Explain the concept of {concept} in detail."
             try:
                 explanation = analyze_issues(prompt, selected_model)
-                return "<pre>{}</pre>".format(explanation)
+                return f"<pre>{explanation}</pre>"
             except Exception as e:
-                logging.error("Error explaining concept: {}".format(e))
-                return "Error explaining concept: {}".format(e)
+                logging.error(f"Error explaining concept: {e}")
+                return "Error explaining concept. Please try again later."
 
     elif command.startswith("/write_documentation"):
         topic = command.replace("/write_documentation", "").strip()
         if not topic:
             return "Please provide a topic for the documentation."
         else:
-            prompt = "Write documentation for the following topic: {}\nProgramming Language: {}".format(topic, programming_language)
+            prompt = f"Write documentation for the following topic: {topic}\nProgramming Language: {programming_language}"
             try:
                 documentation = analyze_issues(prompt, selected_model)
-                return "<pre>{}</pre>".format(documentation)
+                return f"<pre>{documentation}</pre>"
             except Exception as e:
-                logging.error("Error writing documentation: {}".format(e))
-                return "Error writing documentation: {}".format(e)
+                logging.error(f"Error writing documentation: {e}")
+                return "Error writing documentation. Please try again later."
 
     elif command.startswith("/translate_code"):
         try:
             code_and_language = command.replace("/translate_code", "").strip().split(" to ")
             code = code_and_language[0]
             target_language = code_and_language[1]
-            prompt = "Translate the following code to {}:\n\n{}".format(target_language, code)
+            prompt = f"Translate the following code to {target_language}:\n\n{code}"
             try:
                 translated_code = analyze_issues(prompt, selected_model)
-                code_output = "<pre>{}</pre>".format(translated_code)
-                return code_output  # Yield the formatted string
+                code_output = f"<pre>{translated_code}</pre>"
+                return code_output
             except Exception as e:
-                logging.error("Error translating code: {}".format(e))
-                return "Error translating code: {}".format(e)
+                logging.error(f"Error translating code: {e}")
+                return "Error translating code. Please try again later."
         except Exception as e:
-            logging.error("Error parsing translate_code command: {}".format(e))
-            return "Error parsing translate_code command: {}".format(e)
+            logging.error(f"Error parsing translate_code command: {e}")
+            return "Error parsing translate_code command. Please check the syntax."
 
     else:
         messages.append({"role": "user", "content": command})
@@ -275,10 +305,10 @@ def respond(
                 logging.info(f"Received message from chat completion: {message}")
                 token = message.choices[0].delta.content
                 response += token
-                return response
+                yield response # Use yield for streaming responses
         except Exception as e:
             logging.error(f"Error during chat completion: {e}")
-            return "An error occurred: {}".format(e)
+            return "An error occurred. Please try again later."
 
 with gr.Blocks() as demo:
     with gr.Row():
@@ -307,7 +337,7 @@ with gr.Blocks() as demo:
             "bigcode/starcoder" 
         ],
         label="Select Model for Issue Resolution",
-        value="microsoft/CodeBERT-base"
+        value=DEFAULT_MODEL # Set a default model
     )
 
     # Severity Dropdown
@@ -336,7 +366,7 @@ with gr.Blocks() as demo:
     chatbot = gr.ChatInterface(
         respond,
         additional_inputs=[
-            command_dropdown,  # Use command_dropdown instead of a regular message input
+            command_dropdown,
             system_message,
             gr.Slider(minimum=1, maximum=8192, value=2048, step=1, label="Max new tokens"),
             gr.Slider(minimum=0.1, maximum=4.0, value=0.71, step=0.1, label="Temperature"),
@@ -344,7 +374,7 @@ with gr.Blocks() as demo:
                 minimum=0.1,
                 maximum=1.0,
                 value=0.95,
-                step=1.1,
+                step=0.01,
                 label="Top-p (nucleus sampling)",
             ),
             github_api_token,