Update app.py

app.py

@@ -1,292 +1,308 @@
-import gradio as gr
-from transformers import pipeline
-from sentence_transformers import SentenceTransformer, util
 import os
+import sys
+import signal
+import warnings
+import shutil
+import logging
+import json
+import time
+from datetime import datetime
+from typing import List, Dict, Optional, Union
 import requests
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-from huggingface_hub import InferenceClient, HfApi
-import git
-import gitdb
+from requests.exceptions import RequestException
+import gradio as gr
+from git import Repo, GitCommandError
+import base64
+import atexit
 
-# If you have a GPU, move the model to it
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# Suppress warnings
+warnings.filterwarnings('ignore', category=UserWarning)
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
-# Constants for enhanced organization
-system_message = "You are GitBot, the Github project guardian angel. You resolve issues and propose implementation of feature requests"
-max_tokens = 2048
-temperature = 0.71
-top_p = 0.95
+def initialize_environment():
+    """Initialize application environment and configurations"""
+    # Create necessary directories
+    directories = ['logs', 'resolutions', 'repos']
+    for directory in directories:
+        os.makedirs(directory, exist_ok=True)
 
-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
+    # Configure logging
+    log_file = f"logs/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_file),
+            logging.StreamHandler()
+        ]
+    )
 
-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}"
+    # Set up global exception handler
+    def handle_exception(exc_type, exc_value, exc_traceback):
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+        logging.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
 
-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}"
+    sys.excepthook = handle_exception
+    return logging.getLogger(__name__)
 
-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
-        }
+logger = initialize_environment()
 
-class MyChatbot(gr.Chatbot):
-    """Custom Chatbot class for enhanced functionality."""
-    def __init__(self, **kwargs):
-        super().__init__(type="messages", **kwargs)
-        self.issues = []
-        self.current_issue = None
+class GitHubAPI:
+    """GitHub API handler with rate limiting and error handling"""
+    
+    def __init__(self, token: str):
+        self.token = token
+        self.headers = {
+            'Authorization': f'token {token}',
+            'Accept': 'application/vnd.github.v3+json'
+        }
+        self.base_url = "https://api.github.com"
+        self.rate_limit_remaining = None
+        self.rate_limit_reset = None
 
-    def postprocess(self, y):
-        """Post-processes the response to handle commands and display results."""
-        if not y:
-            return []
-            
-        if isinstance(y, dict):
-            assistant_response = y.get('assistant_response', '')
-            command = y.get('command', '')
-        else:
-            assistant_response = str(y)
-            command = ''
+    def _check_rate_limit(self) -> bool:
+        """Check and handle GitHub API rate limits"""
+        try:
+            response = requests.get(f"{self.base_url}/rate_limit", headers=self.headers)
+            response.raise_for_status()
+            limits = response.json()
+            self.rate_limit_remaining = limits['resources']['core']['remaining']
+            self.rate_limit_reset = limits['resources']['core']['reset']
 
-        return [
-            {
-                "role": "assistant",
-                "content": assistant_response
-            }
-        ]
+            if self.rate_limit_remaining < 10:
+                reset_time = datetime.fromtimestamp(self.rate_limit_reset)
+                wait_time = (reset_time - datetime.now()).total_seconds()
+                if wait_time > 0:
+                    logger.warning(f"Rate limit nearly exceeded. Waiting {wait_time:.0f} seconds...")
+                    time.sleep(wait_time)
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Error checking rate limit: {str(e)}")
+            return True
 
-# Main interface
-with gr.Blocks() as demo:
-    with gr.Row():
-        github_api_token = gr.Textbox(label="GitHub API Token", type="password")
-        github_username = gr.Textbox(label="GitHub Username")
-        github_repository = gr.Textbox(label="GitHub Repository")
+    def get_repository(self, owner: str, repo: str) -> Dict:
+        """Get repository information"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/repos/{owner}/{repo}",
+                headers=self.headers
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Error getting repository info: {str(e)}")
+            raise
 
-    system_message = gr.Textbox(
-        value="You are GitBot, the Github project guardian angel. You resolve issues and propose implementation of feature requests",
-        label="System message",
-    )
+    def get_issues(self, owner: str, repo: str, state: str = 'open') -> List[Dict]:
+        """Fetch repository issues"""
+        if not self._check_rate_limit():
+            return []
 
-    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")
+        try:
+            response = requests.get(
+                f"{self.base_url}/repos/{owner}/{repo}/issues",
+                headers=self.headers,
+                params={'state': state}
+            )
+            
+            if response.status_code == 404:
+                logger.error(f"Repository not found: {owner}/{repo}")
+                return []
+            
+            response.raise_for_status()
+            issues = response.json()
+            
+            # Filter out pull requests
+            issues = [issue for issue in issues if 'pull_request' not in issue]
+            
+            logger.info(f"Successfully fetched {len(issues)} issues from {owner}/{repo}")
+            return issues
+            
+        except Exception as e:
+            logger.error(f"Error fetching issues: {str(e)}")
+            return []
 
-    # Create the chatbot instance
-    chatbot = MyChatbot()
-    
-    # Create input textbox for user messages
-    msg = gr.Textbox(label="Message")
+class GitHubBot:
+    """Main GitHub bot implementation"""
     
-    # Create state for storing conversation history
-    state = gr.State([])
+    def __init__(self):
+        self.github_api = None
+        self.issues = []
 
-    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")
+    def initialize_api(self, token: str):
+        """Initialize GitHub API with token"""
+        self.github_api = GitHubAPI(token)
 
-    # Add a dropdown to select an issue
-    issue_dropdown = gr.Dropdown(
-        choices=[],
-        label="Select Issue",
-        interactive=True
-    )
+    def fetch_issues(self, token: str, username: str, repo: str) -> List[Dict]:
+        """Fetch issues from GitHub repository"""
+        try:
+            self.initialize_api(token)
+            issues = self.github_api.get_issues(username, repo)
+            self.issues = issues
+            return issues
+        except Exception as e:
+            logger.error(f"Error fetching issues: {str(e)}")
+            return []
 
-    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 resolve_issue(self, token: str, username: str, repo: str, issue_number: int, resolution: str) -> str:
+        """Resolve a GitHub issue"""
+        try:
+            self.initialize_api(token)
+            
+            # Verify repository exists
+            self.github_api.get_repository(username, repo)
+            
+            # Create resolution file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            resolution_file = f"resolutions/resolution_{issue_number}_{timestamp}.md"
+            
+            with open(resolution_file, "w") as f:
+                f.write(f"# Resolution for Issue #{issue_number}\n\n{resolution}")
+            
+            return f"Resolution saved: {resolution_file}"
+            
+        except Exception as e:
+            error_msg = f"Error resolving issue: {str(e)}"
+            logger.error(error_msg)
+            return error_msg
 
-    def user(user_message, history):
-        """Handle user messages"""
-        return "", history + [[user_message, None]]
+def create_gradio_interface():
+    """Create and configure Gradio interface"""
+    bot = GitHubBot()
 
-    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
-        )
+    with gr.Blocks(title="GitHub Issue Manager") as demo:
+        gr.Markdown("# GitHub Issue Manager")
         
-        history[-1][1] = response['assistant_response']
-        return history
+        with gr.Row():
+            github_token = gr.Textbox(
+                label="GitHub Token",
+                placeholder="Enter your GitHub token",
+                type="password"
+            )
+            github_username = gr.Textbox(
+                label="Repository Owner",
+                placeholder="Enter repository owner username"
+            )
+            github_repo = gr.Textbox(
+                label="Repository Name",
+                placeholder="Enter repository name"
+            )
 
-    def clear_chat():
-        return [], []
+        with gr.Row():
+            fetch_button = gr.Button("Fetch Issues")
+            issue_dropdown = gr.Dropdown(
+                choices=[],
+                label="Select Issue",
+                interactive=True
+            )
 
-    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)])
+        with gr.Row():
+            resolution_text = gr.Textbox(
+                label="Resolution",
+                placeholder="Enter your resolution here...",
+                lines=5
+            )
+            resolve_button = gr.Button("Resolve Issue")
 
-    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 []
+        output_text = gr.Textbox(label="Output", interactive=False)
 
-    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"
+        def fetch_issues_handler(token, username, repo):
+            """Handle issue fetching"""
+            if not all([token, username, repo]):
+                return gr.Dropdown(choices=["Please provide all required fields"])
+            
+            issues = bot.fetch_issues(token, username, repo)
+            if not issues:
+                return gr.Dropdown(choices=["No issues found or error occurred"])
+            
+            return gr.Dropdown(
+                choices=[f"#{issue['number']}: {issue['title']}" for issue in issues]
+            )
 
-    # Connect all the components
-    msg.submit(user, [msg, chatbot], [msg, chatbot]).then(
-        bot,
-        [
-            chatbot,
-            system_message,
-            max_tokens_slider,
-            temperature_slider,
-            top_p_slider,
-            github_api_token,
-            github_username,
-            github_repository,
-            model_dropdown,
-            severity_dropdown,
-            programming_language_textbox
-        ],
-        [chatbot]
-    )
+        def resolve_issue_handler(token, username, repo, selected_issue, resolution):
+            """Handle issue resolution"""
+            if not selected_issue:
+                return "Please select an issue first"
+            
+            try:
+                issue_number = int(selected_issue.split(':')[0][1:])
+                return bot.resolve_issue(token, username, repo, issue_number, resolution)
+            except Exception as e:
+                return f"Error: {str(e)}"
 
-    submit_button.click(user, [msg, chatbot], [msg, chatbot]).then(
-        bot,
-        [
-            chatbot,
-            system_message,
-            max_tokens_slider,
-            temperature_slider,
-            top_p_slider,
-            github_api_token,
-            github_username,
-            github_repository,
-            model_dropdown,
-            severity_dropdown,
-            programming_language_textbox
-        ],
-        [chatbot]
-    )
+        # Connect components
+        fetch_button.click(
+            fetch_issues_handler,
+            inputs=[github_token, github_username, github_repo],
+            outputs=[issue_dropdown]
+        )
 
-    fetch_issues_button.click(
-        fetch_issues,
-        inputs=[github_api_token, github_username, github_repository],
-        outputs=[issue_dropdown]
-    )
+        resolve_button.click(
+            resolve_issue_handler,
+            inputs=[
+                github_token,
+                github_username,
+                github_repo,
+                issue_dropdown,
+                resolution_text
+            ],
+            outputs=[output_text]
+        )
 
-    clear_button.click(
-        clear_chat,
-        outputs=[chatbot, state]
-    )
+    return demo
 
-    issue_dropdown.change(
-        select_issue,
-        inputs=[issue_dropdown, chatbot],
-        outputs=[chatbot]
-    )
+def cleanup():
+    """Cleanup function for graceful shutdown"""
+    try:
+        temp_dirs = ['repos']
+        for dir_name in temp_dirs:
+            if os.path.exists(dir_name):
+                shutil.rmtree(dir_name)
+        logging.shutdown()
+    except Exception as e:
+        print(f"Error during cleanup: {str(e)}")
 
-    resolve_issue_button.click(
-        resolve_selected_issue,
-        inputs=[
-            github_api_token,
-            github_username,
-            github_repository,
-            chatbot
-        ],
-        outputs=[chatbot]
-    )
+def signal_handler(signum, frame):
+    """Handle termination signals"""
+    logger.info(f"Received signal {signum}")
+    cleanup()
+    sys.exit(0)
 
 if __name__ == "__main__":
-    demo.queue().launch(
-        share=True,
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    # Register cleanup handlers
+    atexit.register(cleanup)
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    try:
+        # Create and launch interface
+        demo = create_gradio_interface()
+        
+        # Configure launch parameters
+        is_on_spaces = os.getenv("SPACE_ID") is not None
+        launch_kwargs = {
+            "server_name": "0.0.0.0",
+            "server_port": 7860,
+            "debug": True,
+            "enable_queue": True,
+            "max_threads": 10
+        }
+        
+        if not is_on_spaces:
+            launch_kwargs["share"] = True
+            logger.info("Running in local mode with public URL enabled")
+        else:
+            logger.info("Running on Hugging Face Spaces")
+
+        # Launch application
+        logger.info("Launching Gradio interface...")
+        demo.queue().launch(**launch_kwargs)
+        
+    except Exception as e:
+        logger.error(f"Error launching application: {str(e)}")
+        raise
+    finally:
+        logger.info("Application shutdown")