Update app.py

app.py

@@ -27,10 +27,10 @@ def analyze_issues(issue_text: str, model_name: str, severity: str = None, progr
     Returns:
     str: The analyzed issue and solution.
     """
-    logging.info(f"Analyzing issue: {issue_text} with model: {model_name}")
-    prompt = f"""Issue: {issue_text}
-Severity: {severity}
-Programming Language: {programming_language}
+    logging.info("Analyzing issue: {} with model: {}".format(issue_text, model_name))
+    prompt = """Issue: {}
+Severity: {}
+Programming Language: {}
 Please provide a comprehensive resolution in the following format:
 ## Problem Summary:
 (Concise summary of the issue)
@@ -52,16 +52,16 @@ Please provide a comprehensive resolution in the following format:
 ## 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(f"Pipeline created with model: {model_name}")
+        logging.info("Pipeline created with model: {}".format(model_name))
         result = nlp(prompt)
-        logging.info(f"Model output: {result}")
+        logging.info("Model output: {}".format(result))
         return result[0]['generated_text']
     except Exception as e:
-        logging.error(f"Error analyzing issue with model {model_name}: {e}")
-        return f"Error analyzing issue with model {model_name}: {e}"
+        logging.error("Error analyzing issue with model {}: {}".format(model_name, e))
+        return "Error analyzing issue with model {}: {}".format(model_name, e)
 
 ### Function to find related issues
 def find_related_issues(issue_text: str, issues: list) -> list:
@@ -73,7 +73,7 @@ def find_related_issues(issue_text: str, issues: list) -> list:
     Returns:
     list: The list of related issues.
     """
-    logging.info(f"Finding related issues for: {issue_text}")
+    logging.info("Finding related issues for: {}".format(issue_text))
     issue_embedding = similarity_model.encode(issue_text)
     related_issues = []
     for issue in issues:
@@ -81,7 +81,7 @@ def find_related_issues(issue_text: str, issues: list) -> list:
         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(f"Found related issues: {related_issues}")
+    logging.info("Found related issues: {}".format(related_issues))
     return related_issues[:3]  # Return top 3 most similar issues
 
 ### Function to fetch GitHub issues
@@ -95,20 +95,20 @@ def fetch_github_issues(github_api_token: str, github_username: str, github_repo
     Returns:
     list: The list of GitHub issues.
     """
-    logging.info(f"Fetching GitHub issues for: {github_username}/{github_repository}")
-    url = f"https://api.github.com/repos/{github_username}/{github_repository}/issues"
+    logging.info("Fetching GitHub issues for: {}/{}".format(github_username, github_repository))
+    url = "https://api.github.com/repos/{}/{}/issues".format(github_username, github_repository)
     headers = {
-        "Authorization": f"Bearer {github_api_token}",
+        "Authorization": "Bearer {}".format(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(f"Fetched issues: {issues}")
+        logging.info("Fetched issues: {}".format(issues))
         return issues
     else:
-        logging.error(f"Error fetching issues: {response.status_code}")
-        raise Exception(f"Error fetching issues: {response.status_code}")
+        logging.error("Error fetching issues: {}".format(response.status_code))
+        raise Exception("Error fetching issues: {}".format(response.status_code))
 
 ### Function to handle chat responses
 def respond(
@@ -124,7 +124,6 @@ def respond(
     selected_model: str,
     severity: str,
     programming_language: str,
-    *args  # Add *args here
 ) -> str:
     """
     Handle chat responses.
@@ -150,138 +149,136 @@ def respond(
     issues = []
 
     messages = [{"role": "system", "content": system_message}]
-    logging.info(f"System message: {system_message}")
+    logging.info("System message: {}".format(system_message))
 
     for user_msg, assistant_msg in history:
         if user_msg:
             messages.append({"role": "user", "content": user_msg})
-            logging.info(f"User message: {user_msg}")
+            logging.info("User message: {}".format(user_msg))
         if assistant_msg:
             messages.append({"role": "assistant", "content": assistant_msg})
-            logging.info(f"Assistant message: {assistant_msg}")
+            logging.info("Assistant message: {}".format(assistant_msg))
 
-    logging.info(f"Command received: {command}")
+    logging.info("Command received: {}".format(command))
 
     if command == "/github":
-    if not github_api_token:
-        yield "Please enter your GitHub API token first. <https://github.com/settings/tokens>"
-    else:
-        try:
-            issues = fetch_github_issues(github_api_token, github_username, github_repository)
-            issue_list = "\n".join([f"{i+1}. {issue['title']}" for i, issue in enumerate(issues)])
-            yield f"Available GitHub Issues:\n{issue_list}\n\nEnter the issue number to analyze:"
-        except Exception as e:
-            logging.error(f"Error fetching GitHub issues: {e}")
-            yield f"Error fetching GitHub issues: {e}"
-
-elif command == "/help":
-    help_message = f"""Available commands:
+        if not github_api_token:
+            return "Please enter your GitHub API token first. <https://github.com/settings/tokens>"
+        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)
+            except Exception as e:
+                logging.error("Error fetching GitHub issues: {}".format(e))
+                return "Error fetching GitHub issues: {}".format(e)
+
+  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"""
-    yield help_message  # Yield the pre-formatted help message
-
-elif command.isdigit() and issues:
-    try:
-        issue_number = int(command) - 1
-        issue = issues[issue_number]
-        issue_text = issue['title'] + "\n\n" + issue['body']
-        resolution = analyze_issues(issue_text, selected_model, severity, programming_language)
-
-        # Find and display related issues
-        related_issues = find_related_issues(issue_text, issues)
-        related_issue_text = "\n".join(
-            [f"- {issue['title']} (Similarity: {similarity:.2f})" for issue, similarity in related_issues]
-        )
+        return help_message  # Yield the pre-formatted help message
 
-        yield f"Resolution for Issue '{issue['title']}':\n{resolution}\n\nRelated Issues:\n{related_issue_text}"
-    except Exception as e:
-        logging.error(f"Error analyzing issue: {e}")
-        yield f"Error analyzing issue: {e}"
-
-elif command.startswith("/generate_code"):
-    # Extract the code description from the command
-    code_description = command.replace("/generate_code", "").strip()
-    if not code_description:
-        yield "Please provide a description of the code you want to generate."
-    else:
-        prompt = f"Generate code for the following: {code_description}\nProgramming Language: {programming_language}"
+    elif command.isdigit() and issues:
         try:
-            generated_code = analyze_issues(prompt, selected_model)
-            code_output = f"<pre>{programming_language}\n{generated_code}</pre>"
-            yield code_output  # Yield the formatted string
+            issue_number = int(command) - 1
+            issue = issues[issue_number]
+            issue_text = issue['title'] + "\n\n" + issue['body']
+            resolution = analyze_issues(issue_text, selected_model, severity, programming_language)
+
+            # 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]
+            )
+
+            return "Resolution for Issue '{}':\n{}\n\nRelated Issues:\n{}".format(issue['title'], resolution, related_issue_text)
         except Exception as e:
-            logging.error(f"Error generating code: {e}")
-            yield f"Error generating code: {e}"
-
-elif command.startswith("/explain_concept"):
-    concept = command.replace("/explain_concept", "").strip()
-    if not concept:
-        yield "Please provide a concept to explain."
-    else:
-        prompt = f"Explain the concept of {concept} in detail."
+            logging.error("Error analyzing issue: {}".format(e))
+            return "Error analyzing issue: {}".format(e)
+
+    elif command.startswith("/generate_code"):
+        # Extract the code description from the command
+        code_description = command.replace("/generate_code", "").strip()
+        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)
+            try:
+                generated_code = analyze_issues(prompt, selected_model)
+                code_output = "<pre>{}</pre>".format(generated_code)
+                return code_output  # Yield the formatted string
+            except Exception as e:
+                logging.error("Error generating code: {}".format(e))
+                return "Error generating code: {}".format(e)
+
+    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)
+            try:
+                explanation = analyze_issues(prompt, selected_model)
+                return "<pre>{}</pre>".format(explanation)
+            except Exception as e:
+                logging.error("Error explaining concept: {}".format(e))
+                return "Error explaining concept: {}".format(e)
+
+    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)
+            try:
+                documentation = analyze_issues(prompt, selected_model)
+                return "<pre>{}</pre>".format(documentation)
+            except Exception as e:
+                logging.error("Error writing documentation: {}".format(e))
+                return "Error writing documentation: {}".format(e)
+
+    elif command.startswith("/translate_code"):
         try:
-            explanation = analyze_issues(prompt, selected_model)
-            yield f"<pre>{explanation}</pre>"
+            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)
+            try:
+                translated_code = analyze_issues(prompt, selected_model)
+                code_output = "<pre>{}</pre>".format(translated_code)
+                return code_output  # Yield the formatted string
+            except Exception as e:
+                logging.error("Error translating code: {}".format(e))
+                return "Error translating code: {}".format(e)
         except Exception as e:
-            logging.error(f"Error explaining concept: {e}")
-            yield f"Error explaining concept: {e}"
+            logging.error("Error parsing translate_code command: {}".format(e))
+            return "Error parsing translate_code command: {}".format(e)
 
-elif command.startswith("/write_documentation"):
-    topic = command.replace("/write_documentation", "").strip()
-    if not topic:
-        yield "Please provide a topic for documentation."
     else:
-        prompt = f"Write comprehensive documentation for the following topic: {topic}"
+        messages.append({"role": "user", "content": command})
+        logging.info(f"User message: {command}")
+
+        response = ""
         try:
-            documentation = analyze_issues(prompt, selected_model)
-            yield f"<pre>{documentation}</pre>"
+            for message in client.chat_completion(
+                messages,
+                max_tokens=max_tokens,
+                stream=True,
+                temperature=temperature,
+                top_p=top_p,
+            ):
+                logging.info(f"Received message from chat completion: {message}")
+                token = message.choices[0].delta.content
+                response += token
+                return response
         except Exception as e:
-            logging.error(f"Error writing documentation: {e}")
-            yield f"Error writing documentation: {e}"
-
-elif command.startswith("/translate_code"):
-    parts = command.replace("/translate_code", "").strip().split(" to ")
-    if len(parts) != 2:
-        yield "Invalid command format. Use: /translate_code [code] to [target language]"
-    else:
-        code, target_language = parts
-        prompt = f"Translate the following code to {target_language}:\n\n
-
-
-{code}\n
-
-try:
-translated_code = analyze_issues(prompt, selected_model)
-code_output = f"<pre>{target_language}\n{translated_code}</pre>"
-yield code_output # Yield the formatted string
-except Exception as e:
-logging.error(f"Error translating code: {e}")
-yield f"Error translating code: {e}"
-
-else:
-messages.append({"role": "user", "content": command})
-logging.info(f"User message: {command}")
-
-response = ""
-try:
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        logging.info(f"Received message from chat completion: {message}")
-        token = message.choices[0].delta.content
-        response += token
-        yield response
-except Exception as e:
-    logging.error(f"Error during chat completion: {e}")
-    yield f"An error occurred: {e}"
+            logging.error(f"Error during chat completion: {e}")
+            return "An error occurred: {}".format(e)
 
 with gr.Blocks() as demo:
     with gr.Row():