Update app.py

app.py

@@ -10,52 +10,15 @@ import requests
 import gradio as gr
 import atexit
 import subprocess
-from urllib.parse import urlparse, quote
-import warnings
 import webbrowser
+import urllib.parse
+import warnings
+import torch
+import flask
+from flask import Flask, request, jsonify
 import spaces
-
-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,
-    )
+from accelerate import Accelerator
+from threading import Thread
 
 # Constants
 INPUT_DIRECTORY = 'input'
@@ -64,14 +27,8 @@ 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():
+def initialize_logger() -> logging.Logger:
     log_file = f"{LOGS_DIRECTORY}/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
     logging.basicConfig(
         level=logging.INFO,
@@ -83,9 +40,13 @@ def initialize_logger():
     )
     return logging.getLogger(__name__)
 
-# Initialize environment and logger
-initialize_environment(INPUT_DIRECTORY, OUTPUT_DIRECTORY)
-logger = initialize_logger()  # Initialize logger globally
+# 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()
 
 # GitHub API handler
 class GitHubAPI:
@@ -112,165 +73,81 @@ class GitHubAPI:
                     time.sleep(wait_time)
                 return False
             return True
-        except Exception as e:
+        except requests.exceptions.RequestException as e:
             logger.error(f"Error checking rate limit: {str(e)}")
             return True
 
-    def get_repository(self, owner: str, repo: str) -> Dict:
+    def get_repository(self, owner: str, repo: str) -> Dict[str, Any]:
         try:
             response = requests.get(f"{self.base_url}/repos/{owner}/{repo}", headers=self.headers)
             response.raise_for_status()
             return response.json()
-        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 []
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error getting repository: {str(e)}")
+            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, params={'state': state})
+            response = requests.get(f"{self.base_url}/repos/{owner}/{repo}/issues", headers=self.headers)
             response.raise_for_status()
-            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 response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error getting issues: {str(e)}")
             return []
 
-# 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]:
+    def create_issue(self, owner: str, repo: str, title: str, body: str) -> Dict[str, Any]:
         try:
-            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 []
+            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 {}
 
-    def resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
+    def update_issue(self, owner: str, repo: str, issue_number: int, title: str, body: str) -> Dict[str, Any]:
         try:
-            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()
-
-# Define missing functions with validation
-def fetch_issues(token, repo_url):
-    try:
-        parts = repo_url.split('/')
-        if len(parts) < 2:
-            raise ValueError("Repository URL is not in the correct format. Expected format: 'owner/repo'.")
-
-        owner, repo = parts[-2], parts[-1]
-        issues = bot.fetch_issues(token, owner, repo)
-        return issues
-    except Exception as e:
-        return str(e)
-
-def resolve_issue(token, repo_url, issue_number, resolution, forked_repo_url):
-    try:
-        parts = repo_url.split('/')
-        if len(parts) < 2:
-            raise ValueError("Repository URL is not in the correct format. Expected format: 'owner/repo'.")
-
-        owner, repo = parts[-2], parts[-1]
-        result = bot.resolve_issue(token, owner, repo, issue_number, resolution, forked_repo_url)
-        return result
-    except Exception as e:
-        return str(e)
-
-def extract_info(url):
-    try:
-        info = extract_info_from_url(url)
-        return info
-    except Exception as e:
-        return str(e)
-
-def submit_issue(token, repo_url, issue_number, resolution, forked_repo_url):
-    try:
-        parts = repo_url.split('/')
-        if len(parts) < 2:
-            raise ValueError("Repository URL is not in the correct format. Expected format: 'owner/repo'.")
-
-        owner, repo = parts[-2], parts[-1]
-        result = bot.resolve_issue(token, owner, repo, issue_number, resolution, forked_repo_url)
-        return result
-    except Exception as e:
-        return str(e)
+            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)
 
 # HTML and CSS integration
 custom_html = """
@@ -322,13 +199,16 @@ 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">
+    <div class="card bg-gray-800 p-8"> ```html
         <div class="form-control">
             <label class="label">
                 <span class="label-text">GitHub Token</span>
@@ -346,7 +226,7 @@ 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>
@@ -367,7 +247,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>
@@ -385,6 +265,7 @@ 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');
@@ -397,115 +278,137 @@ 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;
-      }
-      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}`);
+        const token = githubTokenInput.value;
+        const repoUrl = repoUrlInput.value;
+        if (!token || !repoUrl) {
+            outputTextarea.value = "Please provide both GitHub Token and Repository URL.";
+            return;
         }
-        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);
-            });
+        showLoading();
+        try {
+            const response = await fetch('/fetch-issues', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ githubToken: token, repoUrl: repoUrl }),
+ });
+            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 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}`);
+        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 data = await response.json();
-        if (data.error) {
-            outputTextarea.value = data.error;
-        } else {
-            outputTextarea.value = data.result;
+        showLoading();
+        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();
         }
-      } 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;
-      }
-      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 url = urlTextbox.value;
+        if (!url) {
+            outputTextarea.value = "Please provide a URL.";
+            return;
         }
-        const data = await response.json();
-        if (data.error) {
-            outputTextarea.value = data.error;
-        } else {
-            outputTextarea.value = JSON.stringify(data, null, 2);
+        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();
         }
-      } catch (error) {
-        outputTextarea.value = `Error extracting info: ${error.message}`;
-      }
     });
 </script>
 </body>
 </html>
 """
 
-def create_gradio_interface():
+def create_gradio_interface() -> gr.Blocks:
     with gr.Blocks(css=None, theme=None) as demo:
         gr.HTML(custom_html)
-
     return demo
 
 # Cleanup function
-def cleanup():
+def cleanup() -> None:
     try:
         temp_dirs = [REPOS_DIRECTORY]
         for dir_name in temp_dirs:
@@ -516,7 +419,7 @@ def cleanup():
         print(f"Error during cleanup: {str(e)}")
 
 # Signal handler
-def signal_handler(signum, frame):
+def signal_handler(signum: int, frame) -> None:
     logger.info(f"Received signal {signum}")
     cleanup()
     sys.exit(0)
@@ -527,71 +430,10 @@ if __name__ == "__main__":
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
 
-    # Create Gradio interface
-    with gr.Blocks() as demo:
-        # Add HTML template
-        gr.HTML(custom_html)
-        
-        # Create interface components that match the HTML IDs
-        with gr.Row(visible=True):
-            github_token_input = gr.Textbox(label="GitHub Token", elem_id="github-token")
-            repo_url_input = gr.Textbox(label="Repository URL", elem_id="repo-url")
-        
-        with gr.Row(visible=True):
-            issue_dropdown = gr.Dropdown(label="Select Issue", elem_id="issue-dropdown")
-            resolution_textarea = gr.Textbox(label="Resolution", elem_id="resolution-textarea", lines=3)
-            forked_repo_url_input = gr.Textbox(label="Forked Repository URL", elem_id="forked-repo-url")
-        
-        output_area = gr.Textbox(label="Output", elem_id="output-textarea", lines=5)
-        url_textbox = gr.Textbox(label="URL to Extract Info", elem_id="url-textbox")
-
-        # Define buttons with matching elem_ids
-        fetch_button = gr.Button("Fetch Issues", elem_id="fetch-issues")
-        resolve_button = gr.Button("Resolve Issue", elem_id="resolve-issue")
-        extract_button = gr.Button("Extract Info", elem_id="extract-info")
-        submit_button = gr.Button("Submit", elem_id="submit")
-
-        # Connect Python functions to buttons
-        fetch_button.click(
-            fn=fetch_issues,
-            inputs=[github_token_input, repo_url_input],
-            outputs=output_area
-        )
+    # Run Flask app in a separate thread
+    flask_thread = Thread(target=run_flask_app)
+    flask_thread.start()
 
-        resolve_button.click(
-            fn=resolve_issue,
-            inputs=[
-                github_token_input,
-                repo_url_input,
-                issue_dropdown,
-                resolution_textarea,
-                forked_repo_url_input
-            ],
-            outputs=output_area
-        )
-
-        extract_button.click(
-            fn=extract_info,
-            inputs=[url_textbox],
-            outputs=output_area
-        )
-
-        submit_button.click(
-            fn=submit_issue,
-            inputs=[
-                github_token_input,
-                repo_url_input,
-                issue_dropdown,
-                resolution_textarea,
-                forked_repo_url_input
-            ],
-            outputs=output_area
-        )
-
-    # Launch the interface
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        debug=True
-    )
+    # Create Gradio interface
+    demo = create_gradio_interface()
+    demo.launch()