Update app.py

app.py

@@ -18,35 +18,69 @@ max_tokens = 2048
 temperature = 0.71
 top_p = 0.95
 
-class InferenceClient:
-    def __init__(self):
-        pass
+def fetch_github_issues(github_api_token: str, github_username: str, github_repository: str) -> list:
+    """Fetches issues from a specified GitHub repository using the GitHub API."""
+    headers = {'Authorization': f'token {github_api_token}'}
+    url = f"https://api.github.com/repos/{github_username}/{github_repository}/issues"
+    response = requests.get(url, headers=headers)
+    issues = response.json()
+    return issues
 
-    def create_endpoint(self, repo_id, handler_path, model_id, task, description, hyperparameters):
-        pass
+def resolve_issue(github_api_token: str, github_username: str, github_repository: str, issue_number: int, resolution: str):
+    """Resolves an issue by pushing a commit with the resolution."""
+    try:
+        issue_text = fetch_github_issues(github_api_token, github_username, github_repository)[issue_number]['body']
+        commit_message = f"Resolved issue {issue_number}: {issue_text}"
+        commit_file = "resolution.txt"
+        with open(commit_file, "w") as f:
+            f.write(resolution)
+        return push_to_repo(github_api_token, github_username, github_repository, commit_message, commit_file)
+    except Exception as e:
+        return f"Error resolving issue: {e}"
 
-    def update_endpoint(self, repo_id, handler_path, model_id, task, description, hyperparameters):
-        pass
+def push_to_repo(github_api_token: str, github_username: str, github_repository: str, commit_message: str, commit_file: str):
+    """Pushes changes to a GitHub repository."""
+    try:
+        repo = git.Repo.clone_from(f"https://github.com/{github_username}/{github_repository}.git", f"{github_repository}")
+        repo.git.add(commit_file)
+        repo.git.commit(m=commit_message)
+        repo.git.push()
+        return f"Changes pushed to {github_repository} successfully."
+    except gitdb.exc.InvalidGitRepositoryError:
+        return f"Invalid repository: {github_repository}"
+    except Exception as e:
+        return f"Error pushing to repository: {e}"
 
-    def delete_endpoint(self, repo_id, handler_path):
-        pass
-
-    def list_endpoints(self):
-        pass
-
-    def get_endpoint_status(self, repo_id, handler_path):
-        pass
-
-    def get_endpoint_logs(self, repo_id, handler_path, num_lines):
-        pass
-
-    def get_endpoint_metrics(self, repo_id, handler_path):
-        pass
+def respond(command, history, system_message, max_tokens, temperature, top_p, github_api_token, github_username, github_repository, selected_model, severity, programming_language):
+    """Generate a response using the selected model."""
+    try:
+        model = pipeline("text-generation", model=selected_model)
+        prompt = f"{system_message}\nUser: {command}\nAssistant:"
+        
+        response = model(
+            prompt,
+            max_length=max_tokens,
+            do_sample=True,
+            temperature=temperature,
+            top_p=top_p,
+        )
+        
+        return {
+            'assistant_response': response[0]['generated_text'].split("Assistant:")[-1].strip(),
+            'severity': severity,
+            'programming_language': programming_language
+        }
+    except Exception as e:
+        return {
+            'assistant_response': f"Error generating response: {str(e)}",
+            'severity': severity,
+            'programming_language': programming_language
+        }
 
 class MyChatbot(gr.Chatbot):
     """Custom Chatbot class for enhanced functionality."""
     def __init__(self, **kwargs):
-        super().__init__(type="messages", **kwargs)  # Set type to 'messages'
+        super().__init__(type="messages", **kwargs)
         self.issues = []
         self.current_issue = None
 
@@ -69,6 +103,7 @@ class MyChatbot(gr.Chatbot):
             }
         ]
 
+# Main interface
 with gr.Blocks() as demo:
     with gr.Row():
         github_api_token = gr.Textbox(label="GitHub API Token", type="password")
@@ -80,23 +115,22 @@ with gr.Blocks() as demo:
         label="System message",
     )
 
-    model_dropdown = gr.Dropdown(
-        choices=[
-            "mistralai/Mixtral-8x7B-Instruct-v0.1",
-            "Gabriel/Swe-review-setfit-model",
-            "OpenBMB/multilingual-codeparrot"
-        ],
-        label="Select Model for Issue Resolution",
-        value="OpenBMB/multilingual-codeparrot",
-    )
-
-    severity_dropdown = gr.Dropdown(
-        choices=["Critical", "Major", "Minor", "Trivial"],
-        label="Severity",
-        value=None,
-    )
-
-    programming_language_textbox = gr.Textbox(label="Programming Language")
+    with gr.Row():
+        model_dropdown = gr.Dropdown(
+            choices=[
+                "mistralai/Mixtral-8x7B-Instruct-v0.1",
+                "Gabriel/Swe-review-setfit-model",
+                "OpenBMB/multilingual-codeparrot"
+            ],
+            label="Select Model for Issue Resolution",
+            value="OpenBMB/multilingual-codeparrot",
+        )
+        severity_dropdown = gr.Dropdown(
+            choices=["Critical", "Major", "Minor", "Trivial"],
+            label="Severity",
+            value=None,
+        )
+        programming_language_textbox = gr.Textbox(label="Programming Language")
 
     # Create the chatbot instance
     chatbot = MyChatbot()
@@ -107,11 +141,11 @@ with gr.Blocks() as demo:
     # Create state for storing conversation history
     state = gr.State([])
 
-    # Add buttons with correct syntax
-    fetch_issues_button = gr.Button("Fetch Issues")
-    resolve_issue_button = gr.Button("Resolve Issue")
-    clear_button = gr.Button("Clear Chat")
-    submit_button = gr.Button("Submit Message")
+    with gr.Row():
+        fetch_issues_button = gr.Button("Fetch Issues")
+        resolve_issue_button = gr.Button("Resolve Issue")
+        clear_button = gr.Button("Clear Chat")
+        submit_button = gr.Button("Submit Message")
 
     # Add a dropdown to select an issue
     issue_dropdown = gr.Dropdown(
@@ -120,38 +154,80 @@ with gr.Blocks() as demo:
         interactive=True
     )
 
+    with gr.Row():
+        max_tokens_slider = gr.Slider(minimum=1, maximum=8192, value=2048, step=1, label="Max new tokens")
+        temperature_slider = gr.Slider(minimum=0.1, maximum=4.0, value=0.71, step=0.1, label="Temperature")
+        top_p_slider = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.01, label="Top-p")
+
+    def user(user_message, history):
+        """Handle user messages"""
+        return "", history + [[user_message, None]]
+
+    def bot(history, system_msg, max_tokens, temp, top_p, api_token, username, repo, model, severity, lang):
+        """Generate bot response"""
+        if len(history) == 0:
+            return history
+            
+        user_message = history[-1][0]
+        response = respond(
+            command=user_message,
+            history=history[:-1],
+            system_message=system_msg,
+            max_tokens=max_tokens,
+            temperature=temp,
+            top_p=top_p,
+            github_api_token=api_token,
+            github_username=username,
+            github_repository=repo,
+            selected_model=model,
+            severity=severity,
+            programming_language=lang
+        )
+        
+        history[-1][1] = response['assistant_response']
+        return history
+
     def clear_chat():
         return [], []
 
     def fetch_issues(api_token, username, repo):
+        """Fetch GitHub issues and update the chatbot"""
         issues = fetch_github_issues(api_token, username, repo)
         chatbot.issues = issues
         return gr.Dropdown(choices=[f"{i+1}. {issue['title']}" for i, issue in enumerate(issues)])
 
-    # Connect button events
-    fetch_issues_button.click(
-        fetch_issues,
-        inputs=[github_api_token, github_username, github_repository],
-        outputs=[issue_dropdown]
-    )
+    def select_issue(selected, chatbot):
+        """Handle issue selection"""
+        if selected:
+            issue_num = int(selected.split('.')[0]) - 1
+            chatbot.current_issue = chatbot.issues[issue_num]
+            return chatbot.postprocess({
+                'command': str(issue_num + 1),
+                'github_api_token': github_api_token.value,
+                'github_username': github_username.value,
+                'github_repository': github_repository.value,
+                'selected_model': model_dropdown.value,
+                'severity': severity_dropdown.value,
+                'programming_language': programming_language_textbox.value
+            })
+        return []
 
-    clear_button.click(
-        clear_chat,
-        outputs=[chatbot, state]
-    )
+    def resolve_selected_issue(api_token, username, repo, resolution):
+        """Resolve the currently selected issue"""
+        if chatbot.current_issue:
+            issue_number = chatbot.issues.index(chatbot.current_issue)
+            return resolve_issue(api_token, username, repo, issue_number, resolution)
+        return "No issue selected"
 
-    submit_button.click(
-        user,
-        [msg, chatbot],
-        [msg, chatbot]
-    ).then(
+    # Connect all the components
+    msg.submit(user, [msg, chatbot], [msg, chatbot]).then(
         bot,
         [
             chatbot,
             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"),
-            gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.01, label="Top-p"),
+            max_tokens_slider,
+            temperature_slider,
+            top_p_slider,
             github_api_token,
             github_username,
             github_repository,
@@ -162,19 +238,14 @@ with gr.Blocks() as demo:
         [chatbot]
     )
 
-    # Add message input handler
-    msg.submit(
-        user,
-        [msg, chatbot],
-        [msg, chatbot]
-    ).then(
+    submit_button.click(user, [msg, chatbot], [msg, chatbot]).then(
         bot,
         [
             chatbot,
             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"),
-            gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.01, label="Top-p"),
+            max_tokens_slider,
+            temperature_slider,
+            top_p_slider,
             github_api_token,
             github_username,
             github_repository,
@@ -185,14 +256,23 @@ with gr.Blocks() as demo:
         [chatbot]
     )
 
-    # Issue selection handler
+    fetch_issues_button.click(
+        fetch_issues,
+        inputs=[github_api_token, github_username, github_repository],
+        outputs=[issue_dropdown]
+    )
+
+    clear_button.click(
+        clear_chat,
+        outputs=[chatbot, state]
+    )
+
     issue_dropdown.change(
         select_issue,
         inputs=[issue_dropdown, chatbot],
         outputs=[chatbot]
     )
 
-    # Issue resolution handler
     resolve_issue_button.click(
         resolve_selected_issue,
         inputs=[