Update app.py

app.py

@@ -10,15 +10,52 @@ import requests
 import gradio as gr
 import atexit
 import subprocess
-import webbrowser
-import urllib.parse
+from urllib.parse import urlparse, quote
 import warnings
-import torch
-import flask
-from flask import Flask, request, jsonify
+import webbrowser
 import spaces
-from accelerate import Accelerator
-from threading import Thread
+
+device = "cuda"
+
+@spaces.GPU()
+def stream_chat(
+    message: str,
+    history: list,
+    system_prompt: str,
+    temperature: float = 0.8,
+    max_new_tokens: int = 1024,
+    top_p: float = 1.0,
+    top_k: int = 20,
+    penalty: float = 1.2,
+):
+    print(f'message: {message}')
+    print(f'history: {history}')
+
+    conversation = [
+        {"role": "system", "content": system_prompt}
+    ]
+    for prompt, answer in history:
+        conversation.extend([
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": answer},
+        ])
+
+    conversation.append({"role": "user", "content": message})
+
+    input_ids = tokenizer.apply_chat_template(conversation, add_generation_prompt=True, return_tensors="pt").to(model.device)
+
+    streamer = TextIteratorStreamer(tokenizer, timeout=60.0, skip_prompt=True, skip_special_tokens=True)
+
+    generate_kwargs = dict(
+        input_ids=input_ids,
+        max_new_tokens = max_new_tokens,
+        do_sample = False if temperature == 0 else True,
+        top_p = top_p,
+        top_k = top_k,
+        temperature = temperature,
+        eos_token_id=[128001,128008,128009],
+        streamer=streamer,
+    )
 
 # Constants
 INPUT_DIRECTORY = 'input'
@@ -27,8 +64,14 @@ LOGS_DIRECTORY = 'logs'
 RESOLUTIONS_DIRECTORY = 'resolutions'
 REPOS_DIRECTORY = 'repos'
 
+# Set up environment
+def initialize_environment(input_file, output_directory):
+    directories = [LOGS_DIRECTORY, RESOLUTIONS_DIRECTORY, REPOS_DIRECTORY, input_file, output_directory]
+    for directory in directories:
+        os.makedirs(directory, exist_ok=True)
+
 # Set up logging
-def initialize_logger() -> logging.Logger:
+def initialize_logger():
     log_file = f"{LOGS_DIRECTORY}/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
     logging.basicConfig(
         level=logging.INFO,
@@ -40,13 +83,9 @@ def initialize_logger() -> logging.Logger:
     )
     return logging.getLogger(__name__)
 
-# Set up environment
-@spaces.GPU
-def initialize_environment(input_file: str, output_directory: str) -> logging.Logger:
-    directories = [LOGS_DIRECTORY, RESOLUTIONS_DIRECTORY, REPOS_DIRECTORY, input_file, output_directory]
-    for directory in directories:
-        os.makedirs(directory, exist_ok=True)
-    return initialize_logger()
+# Initialize environment and logger
+initialize_environment(INPUT_DIRECTORY, OUTPUT_DIRECTORY)
+logger = initialize_logger()  # Initialize logger globally
 
 # GitHub API handler
 class GitHubAPI:
@@ -73,81 +112,121 @@ class GitHubAPI:
                     time.sleep(wait_time)
                 return False
             return True
-        except requests.exceptions.RequestException as e:
+        except Exception as e:
             logger.error(f"Error checking rate limit: {str(e)}")
             return True
 
-    def get_repository(self, owner: str, repo: str) -> Dict[str, Any]:
+    def get_repository(self, owner: str, repo: str) -> Dict:
         try:
             response = requests.get(f"{self.base_url}/repos/{owner}/{repo}", headers=self.headers)
             response.raise_for_status()
             return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error getting repository: {str(e)}")
-            return {}
+        except requests.HTTPError as e:
+            logger.error(f"HTTP error getting repository info: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error getting repository info: {str(e)}")
+            raise
+
+    def get_issues(self, owner: str, repo: str, state: str = 'open') -> List[Dict]:
+        if not self._check_rate_limit():
+            return []
 
-    def get_issues(self, owner: str, repo: str) -> List[Dict[str, Any]]:
         try:
-            response = requests.get(f"{self.base_url}/repos/{owner}/{repo}/issues", headers=self.headers)
+            response = requests.get(f"{self.base_url}/repos/{owner}/{repo}/issues", headers=self.headers, params={'state': state})
             response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error getting issues: {str(e)}")
+            issues = response.json()
+            return [issue for issue in issues if 'pull_request' not in issue]
+        except Exception as e:
+            logger.error(f"Error fetching issues: {str(e)}")
             return []
 
-    def create_issue(self, owner: str, repo: str, title: str, body: str) -> Dict[str, Any]:
+# GitHub Bot
+class GitHubBot:
+    def __init__(self):
+        self.github_api = None
+
+    def initialize_api(self, token: str):
+        self.github_api = GitHubAPI(token)
+
+    def fetch_issues(self, token: str, owner: str, repo: str) -> List[Dict]:
         try:
-            response = requests.post(f"{self.base_url}/repos/{owner}/{repo}/issues", headers=self.headers, json={'title': title, 'body': body})
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error creating issue: {str(e)}")
-            return {}
+            self.initialize_api(token)
+            return self.github_api.get_issues(owner, repo)
+        except Exception as e:
+            logger.error(f"Error fetching issues: {str(e)}")
+            return []
 
-    def update_issue(self, owner: str, repo: str, issue_number: int, title: str, body: str) -> Dict[str, Any]:
+    def resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
         try:
-            response = requests.patch(f"{self.base_url}/repos/{owner}/{repo}/issues/{issue_number}", headers=self.headers, json={'title': title, 'body': body})
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error updating issue: {str(e)}")
-            return {}
-
-app = Flask(__name__)
-
-@app.route('/fetch-issues', methods=['POST'])
-def fetch_issues() -> Dict[str, Any]:
-    data = request.get_json()
-    github_token = data['githubToken']
-    repo_url = data['repoUrl']
-    owner, repo = repo_url.split('/')[-2:]
-    github_api = GitHubAPI(github_token)
-    issues = github_api.get_issues(owner , repo)
-    return jsonify({'issues': issues})
-
-@app.route('/resolve-issue', methods=['POST'])
-def resolve_issue() -> Dict[str, Any]:
-    data = request.get_json()
-    github_token = data['githubToken']
-    repo_url = data['repoUrl']
-    issue = data['issue']
-    resolution = data['resolution']
-    forked_repo_url = data['forkedRepoUrl']
-    owner, repo = repo_url.split('/')[-2:]
-    github_api = GitHubAPI(github_token)
-    issue_number = issue['number']
-    github_api.update_issue(owner, repo, issue_number, issue['title'], resolution)
-    return jsonify({'output': f"Issue {issue_number} resolved"})
-
-@app.route('/extract-info', methods=['POST'])
-def extract_info() -> Dict[str, Any]:
-    data = request.get_json()
-    url = data['url']
-    # Extract info from URL
-    return jsonify({'output': f"Info extracted from {url}"})
-
-def run_flask_app() -> None:
-    app.run(debug=True, use_reloader=False)
+            self.initialize_api(token)
+            self.github_api.get_repository(owner, repo)
+
+            # Create resolution file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            resolution_file = f"{RESOLUTIONS_DIRECTORY}/resolution_{issue_number}_{timestamp}.md"
+
+            with open(resolution_file, "w") as f:
+                f.write(f"# Resolution for Issue #{issue_number}\n\n{resolution}")
+
+            # Clone the forked repo
+            subprocess.run(['git', 'clone', forked_repo, '/tmp/' + forked_repo.split('/')[-1]], check=True)
+
+            # Change to the cloned directory
+            os.chdir('/tmp/' + forked_repo.split('/')[-1])
+
+            # Assuming manual intervention now
+            input(" Apply the fix manually and stage the changes (press ENTER)? ")
+
+            # Commit and push the modifications
+            subprocess.run(['git', 'add', '.'], check=True)
+            subprocess.run(['git', 'commit', '-m', f"Resolved issue #{issue_number} ({quote(resolution)})"], check=True)
+            subprocess.run(['git', 'push', 'origin', 'HEAD'], check=True)
+
+            # Open Pull Request page
+            webbrowser.open(f'https://github.com/{forked_repo.split("/")[-1]}/compare/master...{owner}:{forked_repo.split("/")[-1]}_resolved_issue_{issue_number}')
+
+            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 handle_issue_selection(token, owner, repo, issue_number, resolution, forked_repo):
+    bot = GitHubBot()
+    result = bot.resolve_issue(token, owner, repo, issue_number, resolution, forked_repo)
+    return result
+
+def extract_info_from_url(url: str) -> Dict[str, Any]:
+    info = {}
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        info['status_code'] = response.status_code
+        info['headers'] = dict(response.headers)
+        info['content'] = response.text[:500]  # Limit content to first 500 characters for brevity
+
+        parsed_url = urlparse(url)
+        if 'github.com' in parsed_url.netloc:
+            parts = parsed_url.path.split('/')
+            if len(parts) > 2:
+                owner = parts[1]
+                repo = parts[2]
+                issues = bot.fetch_issues(github_token, owner, repo)
+                info['issues'] = issues
+        elif 'huggingface.co' in parsed_url.netloc:
+            # Add Hugging Face specific handling if needed
+            pass
+
+    except requests.HTTPError as e:
+        info['error'] = f"HTTP error: {str(e)}"
+    except Exception as e:
+        info['error'] = f"Error: {str(e)}"
+    return info
+
+# Initialize GitHubBot globally
+bot = GitHubBot()
 
 # HTML and CSS integration
 custom_html = """
@@ -165,6 +244,7 @@ custom_html = """
             color: #e0e0e0;
             font-family: 'Roboto', sans-serif;
             overflow-x: hidden; /* Prevent horizontal scrollbar */
+
         }
         .card {
             border-radius: 1.5rem;
@@ -199,13 +279,10 @@ custom_html = """
             color: white;
             border: 2px solid #22c55e;
         }
-        .loading {
-            display: none;
-        }
     </style>
 </head>
 <body class="bg-gray-900">
-<div class="container mx-auto p-4">
+<div class="container mx-auto p-4" >
     <h1 class="text-4xl md:text-5xl font-extrabold text-center mb-8">GitHub Issue Manager</h1>
     <!-- GitHub Token & Repo URL -->
     <div class="card bg-gray-800 p-8">
@@ -226,11 +303,12 @@ custom_html = """
     <div class="card bg-gray-800 p-8">
         <div class="flex justify-between gap-4">
             <button class="btn btn-primary" id="fetch-issues">Fetch Issues</button>
-            <select class="select select-primary w-full max-w-xs" id="issue-dropdown">
+            <select class="select select-primary w-full max-w-xs" id="issue-dropdown" >
                 <option disabled selected>Select Issue</option>
             </select>
         </div>
-        <div class="form-control mt-4 <label class="label">
+        <div class="form-control mt-4">
+            <label class="label">
                 <span class="label-text">Resolution</span>
             </label>
             <textarea class="textarea textarea-primary" placeholder="Enter the resolution details" id="resolution-textarea"></textarea>
@@ -246,7 +324,7 @@ custom_html = """
         </div>
     </div>
     <!-- Output Area -->
-    <div class="card bg-gray-800 p-8 mt-4">
+    <div class="card bg-gray-800 p-8 mt-4" >
         <label class="label">
             <span class="label-text">Output</span>
         </label>
@@ -264,7 +342,6 @@ custom_html = """
             <button class="btn btn-primary" id="extract-info">Extract Info</button>
         </div>
     </div>
-    <div class="loading" id="loading-indicator">Loading...</div>
 </div>
 <script>
     const githubTokenInput = document.getElementById('github-token');
@@ -277,137 +354,112 @@ custom_html = """
     const outputTextarea = document.getElementById('output-textarea');
     const urlTextbox = document.getElementById('url-textbox');
     const extractInfoButton = document.getElementById('extract-info');
-    const loadingIndicator = document.getElementById('loading-indicator');
-
-    const showLoading = () => {
-        loadingIndicator.style.display = 'block';
-        fetchIssuesButton.disabled = true;
-        resolveIssueButton.disabled = true;
-        extractInfoButton.disabled = true;
-    };
-
-    const hideLoading = () => {
-        loadingIndicator.style.display = 'none';
-        fetchIssuesButton.disabled = false;
-        resolveIssueButton.disabled = false;
-        extractInfoButton.disabled = false;
-    };
-
     fetchIssuesButton.addEventListener('click', async () => {
-        const token = githubTokenInput.value;
-        const repoUrl = repoUrlInput.value;
-        if (!token || !repoUrl) {
-            outputTextarea.value = "Please provide both GitHub Token and Repository URL.";
-            return;
+      const token = githubTokenInput.value;
+      const repoUrl = repoUrlInput.value;
+      if (!token || !repoUrl) {
+        outputTextarea.value = "Please provide both GitHub Token and Repository URL.";
+        return;
+      }
+      try {
+        const response = await fetch('/fetch_issues', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ token: token, repoUrl: repoUrl }),
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
         }
-        showLoading();
-        try {
-            const response = await fetch('/fetch-issues', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ githubToken: token, repoUrl: repoUrl }),
+        const data = await response.json();
+        if (data.error) {
+            outputTextarea.value = data.error;
+        } else {
+            issueDropdown.innerHTML = '';
+            data.issues.forEach(issue => {
+                const option = document.createElement('option');
+                option.value = issue.number;
+                option.text = `${issue.number}: ${issue.title}`;
+                issueDropdown.add(option);
             });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (data.error) {
-                outputTextarea.value = data.error;
-            } else {
-                issueDropdown.innerHTML = '';
-                data.issues.forEach(issue => {
-                    const option = document.createElement('option');
-                    option.value = JSON.stringify(issue);
-                    option.text = `${issue.number}: ${issue.title}`;
-                    issueDropdown.add(option);
-                });
-            }
-        } catch (error) {
-            outputTextarea.value = `Error fetching issues: ${error.message}`;
-        } finally {
-            hideLoading();
         }
+      } catch (error) {
+        outputTextarea.value = `Error fetching issues: ${error.message}`;
+      }
     });
-
     resolveIssueButton.addEventListener('click', async () => {
-        const token = githubTokenInput.value;
-        const repoUrl = repoUrlInput.value;
-        const issue = JSON.parse(issueDropdown.value);
-        const resolution = resolutionTextarea.value;
-        const forkedRepoUrl = forkedRepoUrlInput.value;
-        if (!token || !repoUrl || !issue || !resolution) {
-            outputTextarea.value = "Please provide all required fields.";
-            return;
+      const token = githubTokenInput.value;
+      const repoUrl = repoUrlInput.value;
+      const issueNumber = issueDropdown.value;
+      const resolution = resolutionTextarea.value;
+      const forkedRepoUrl = forkedRepoUrlInput.value;
+      if (!token || !repoUrl || !issueNumber || !resolution) {
+        outputTextarea.value ="Please provide all required fields.";
+        return;
+      }
+      try {
+        const response = await fetch('/resolve_issue', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ token: token, repoUrl: repoUrl, issueNumber: issueNumber, resolution: resolution, forkedRepoUrl: forkedRepoUrl }),
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
         }
-        show Loading();
-        try {
-            const response = await fetch('/resolve-issue', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ githubToken: token, repoUrl: repoUrl, issue: issue, resolution: resolution, forkedRepoUrl: forkedRepoUrl }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (data.error) {
-                outputTextarea.value = data.error;
-            } else {
-                outputTextarea.value = data.output;
-            }
-        } catch (error) {
-            outputTextarea.value = `Error resolving issue: ${error.message}`;
-        } finally {
-            hideLoading();
+        const data = await response.json();
+        if (data.error) {
+            outputTextarea.value = data.error;
+        } else {
+            outputTextarea.value = data.result;
         }
+      } catch (error) {
+        outputTextarea.value = `Error resolving issue: ${error.message}`;
+      }
     });
-
     extractInfoButton.addEventListener('click', async () => {
-        const url = urlTextbox.value;
-        if (!url) {
-            outputTextarea.value = "Please provide a URL.";
-            return;
+      const url = urlTextbox.value;
+      if (!url) {
+        outputTextarea.value = "Please provide a URL.";
+        return;
+      }
+      try {
+        const response = await fetch('/extract_info', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ url: url }),
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
         }
-        showLoading();
-        try {
-            const response = await fetch('/extract-info', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ url: url }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (data.error) {
-                outputTextarea.value = data.error;
-            } else {
-                outputTextarea.value = data.output;
-            }
-        } catch (error) {
-            outputTextarea.value = `Error extracting info: ${error.message}`;
-        } finally {
-            hideLoading();
+        const data = await response.json();
+        if (data.error) {
+            outputTextarea.value = data.error;
+        } else {
+            outputTextarea.value = JSON.stringify(data, null, 2);
         }
+      } catch (error) {
+        outputTextarea.value = `Error extracting info: ${error.message}`;
+      }
     });
+
 </script>
 </body>
 </html>
 """
 
-def create_gradio_interface() -> gr.Blocks:
+def create_gradio_interface():
     with gr.Blocks(css=None, theme=None) as demo:
         gr.HTML(custom_html)
+
     return demo
 
 # Cleanup function
-def cleanup() -> None:
+def cleanup():
     try:
         temp_dirs = [REPOS_DIRECTORY]
         for dir_name in temp_dirs:
@@ -418,7 +470,7 @@ def cleanup() -> None:
         print(f"Error during cleanup: {str(e)}")
 
 # Signal handler
-def signal_handler(signum: int, frame) -> None:
+def signal_handler(signum, frame):
     logger.info(f"Received signal {signum}")
     cleanup()
     sys.exit(0)
@@ -429,10 +481,53 @@ if __name__ == "__main__":
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
 
-    # Run Flask app in a separate thread
-    flask_thread = Thread(target=run_flask_app)
-    flask_thread.start()
-
     # Create Gradio interface
     demo = create_gradio_interface()
+
+    # Define Gradio endpoints
+    def fetch_issues(github_token, repo_url):
+        try:
+            issues = bot.fetch_issues(github_token, repo_url.split('/')[-2], repo_url.split('/')[-1])
+            return {'issues': issues}
+        except Exception as e:
+            return {'error': str(e)}
+
+    def resolve_issue(github_token, repo_url, issue_number, resolution, forked_repo_url):
+        try:
+            result = handle_issue_selection(github_token, repo_url.split('/')[-2], repo_url.split('/')[-1], issue_number, resolution, forked_repo_url)
+            return {'result': result}
+        except Exception as e:
+            return {'error': str(e)}
+
+    def extract_info(url):
+        try:
+            info = extract_info_from_url(url)
+            return info
+        except Exception as e:
+            return {'error': str(e)}
+
+    # Define Gradio interface
+    demo = gr.Blocks()
+    with demo:
+        gr.HTML(custom_html)
+
+        # Fetch issues endpoint
+        fetch_issues_button = gr.Button("Fetch Issues")
+        fetch_issues_button.click(
+            lambda: gr.update(value=fetch_issues(github_token_input.value, repo_url_input.value))
+        )
+
+        # Resolve issue endpoint
+        resolve_issue_button = gr.Button("Resolve Issue")
+        resolve_issue_button.click(
+            lambda: gr.update(value=resolve_issue(github_token_input.value, repo_url_input.value, issue_dropdown.value, resolution_textarea.value, forked_repo_url_input.value))
+        )
+
+        # Extract info endpoint
+        extract_info_button = gr.Button("Extract Info")
+        extract_info_button.click(
+            lambda: gr.update(value=extract_info(url_textbox.value))
+        )
+
+    # Launch Gradio interface
     demo.launch()