Update app.py

app.py

@@ -1,19 +1,9 @@
-import sys
-import signal
-import shutil
-import logging
-import time
+from flask import Flask, render_template, request, jsonify
+import requests
 import os
+import logging
 from datetime import datetime
-from typing import List, Dict, Any
-import requests
-import gradio as gr
-import atexit
-import subprocess
-from urllib.parse import urlparse, quote
-import webbrowser
-from flask import Flask, request, jsonify, send_from_directory
-from threading import Thread
+
 
 device = "cuda"
 
@@ -56,296 +46,97 @@ def stream_chat(
         eos_token_id=[128001, 128008, 128009],
         streamer=streamer,
     )
+app = Flask(__name__)
 
-# Constants
-INPUT_DIRECTORY = 'input'
-OUTPUT_DIRECTORY = 'output'
+# Configure logging
 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():
-    log_file = f"{LOGS_DIRECTORY}/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()
-        ]
-    )
-    return logging.getLogger(__name__)
-
-# Initialize environment and logger
-initialize_environment(INPUT_DIRECTORY, OUTPUT_DIRECTORY)
-logger = initialize_logger()  # Initialize logger globally
-
-# GitHub API handler
-class GitHubAPI:
-    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"
-
-    def _check_rate_limit(self) -> bool:
-        try:
-            response = requests.get(f"{self.base_url}/rate_limit", headers=self.headers)
-            response.raise_for_status()
-            limits = response.json()
-            remaining = limits['resources']['core']['remaining']
-            reset_time = limits['resources']['core']['reset']
-
-            if remaining < 10:
-                wait_time = max(0, reset_time - int(time.time()))
-                if wait_time > 0:
-                    logger.warning(f"Rate limit nearly exceeded. Waiting {wait_time} seconds...")
-                    time.sleep(wait_time)
-                return False
-            return True
-        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:
-        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 []
-
-        try:
-            response = requests.get(f"{self.base_url}/repos/{owner}/{repo}/issues", headers=self.headers, params={'state': state})
-            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 []
-
-# 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:
-            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 resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
-        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}')
+if not os.path.exists(LOGS_DIRECTORY):
+    os.makedirs(LOGS_DIRECTORY)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(f"{LOGS_DIRECTORY}/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
 
-            return f"Resolution saved: {resolution_file}"
+@app.route('/')
+def index():
+    return render_template('index.html')
 
-        except Exception as e:
-            error_msg = f"Error resolving issue: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
+@app.route('/fetch_issues', methods=['POST'])
+def fetch_issues():
+    github_token = request.form.get('github_token')
+    repo_url = request.form.get('repo_url')
 
-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
+    if not github_token or not repo_url:
+        logger.error('GitHub Token and Repository URL are required')
+        return jsonify({'error': 'GitHub Token and Repository URL are required'}), 400
 
-def extract_info_from_url(url: str) -> Dict[str, Any]:
-    info = {}
     try:
-        response = requests.get(url)
+        repo_owner, repo_name = repo_url.split('/')[-2:]
+        headers = {'Authorization': f'token {github_token}'}
+        response = requests.get(f'https://api.github.com/repos/{repo_owner}/{repo_name}/issues', headers=headers)
         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
+        issues = response.json()
+        logger.info(f'Successfully fetched issues for {repo_owner}/{repo_name}')
+        return jsonify(issues)
+    except requests.exceptions.RequestException as e:
+        logger.error(f'Error fetching issues: {str(e)}')
+        return jsonify({'error': str(e)}), 500
 
-    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)
+@app.route('/resolve_issue', methods=['POST'])
+def resolve_issue():
+    github_token = request.form.get('github_token')
+    issue_number = request.form.get('issue_number')
+    resolution = request.form.get('resolution')
+    repo_url = request.form.get('repo_url')
+    forked_repo_url = request.form.get('forked_repo_url')
 
-def extract_info(url):
-    try:
-        info = extract_info_from_url(url)
-        return info
-    except Exception as e:
-        return str(e)
+    if not github_token or not issue_number or not resolution or not repo_url:
+        logger.error('GitHub Token, Issue Number, Resolution, and Repository URL are required')
+        return jsonify({'error': 'GitHub Token, Issue Number, Resolution, and Repository URL are required'}), 400
 
-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'.")
+        repo_owner, repo_name = repo_url.split('/')[-2:]
+        headers = {'Authorization': f'token {github_token}'}
 
-        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)
+        # Create a comment with the resolution in the issue
+        comment_data = {"body": resolution}
+        requests.post(f'https://api.github.com/repos/{repo_owner}/{repo_name}/issues/{issue_number}/comments', headers=headers, json=comment_data)
 
-app = Flask(__name__)
-
-@app.route('/index')
-def serve_index():
-    return send_from_directory('.', 'index.html')
+        if forked_repo_url:
+            # Extract the forked repo's owner and name
+            forked_repo_owner, forked_repo_name = forked_repo_url.split('/')[-2:]
 
-@app.route('/fetch_issues', methods=['POST'])
-def fetch_issues_route():
-    data = request.get_json()
-    token = data.get('token')
-    repo_url = data.get('repoUrl')
-    if not token or not repo_url:
-        return jsonify({'error': 'Missing token or repoUrl'}), 400
-    issues = fetch_issues(token, repo_url)
-    return jsonify({'issues': issues})
+            # Close the issue in your forked repository
+            close_issue_data = {"state": "closed"}
+            requests.patch(f'https://api.github.com/repos/{forked_repo_owner}/{forked_repo_name}/issues/{issue_number}', headers=headers, json=close_issue_data)
 
-@app.route('/resolve_issue', methods=['POST'])
-def resolve_issue_route():
-    data = request.get_json()
-    token = data.get('token')
-    repo_url = data.get('repoUrl')
-    issue_number = data.get('issueNumber')
-    resolution = data.get('resolution')
-    forked_repo_url = data.get('forkedRepoUrl')
-    if not token or not repo_url or not issue_number or not resolution:
-        return jsonify({'error': 'Missing required fields'}), 400
-    result = resolve_issue(token, repo_url, issue_number, resolution, forked_repo_url)
-    return jsonify({'result': result})
+        logger.info(f'Issue #{issue_number} resolved successfully')
+        return jsonify({'message': f'Issue #{issue_number} resolved successfully'})
+    except requests.exceptions.RequestException as e:
+        logger.error(f'Error resolving issue: {str(e)}')
+        return jsonify({'error': str(e)}), 500
 
 @app.route('/extract_info', methods=['POST'])
-def extract_info_route():
-    data = request.get_json()
-    url = data.get('url')
+def extract_info():
+    url = request.form.get('url')
     if not url:
-        return jsonify({'error': 'Missing URL'}), 400
-    info = extract_info(url)
-    return jsonify(info)
-
-def run_flask_app():
-    app.run(debug=True, use_reloader=False)
-
-def create_gradio_interface():
-    with gr.Blocks(css=None, theme=None) as demo:
-        gr.HTML(custom_html)
-
-    return demo
-
-# Cleanup function
-def cleanup():
+        logger.error('URL is required')
+        return jsonify({'error': 'URL is required'}), 400
     try:
-        temp_dirs = [REPOS_DIRECTORY]
-        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)}")
-
-# Signal handler
-def signal_handler(signum, frame):
-    logger.info(f"Received signal {signum}")
-    cleanup()
-    sys.exit(0)
-
-if __name__ == "__main__":
-    # Register cleanup handlers
-    atexit.register(cleanup)
-    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()
-    demo.launch()
+        headers = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36"}
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        logger.info(f'Successfully extracted info from {url}')
+        return jsonify({"status": "success", "response": response.text})
+    except requests.exceptions.RequestException as e:
+        logger.error(f'Error extracting info: {str(e)}')
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True)