Update app.py

app.py

@@ -1,4 +1,3 @@
-
 import sys
 import signal
 import warnings
@@ -8,8 +7,7 @@ import spaces
 import time
 import os
 from datetime import datetime
-from typing import List, Dict, Optional, Union
-from pathlib import Path
+from typing import List, Dict
 import requests
 import gradio as gr
 import atexit
@@ -17,160 +15,150 @@ import subprocess
 import webbrowser
 import urllib.parse
 import http.client
-from functools import lru_cache
-import json
-from concurrent.futures import ThreadPoolExecutor
-
-# Security and configuration constants
-MAX_RETRIES = 3
-REQUEST_TIMEOUT = 30
-RATE_LIMIT_THRESHOLD = 10
-CACHE_TTL = 300  # 5 minutes cache
-
-# Suppress warnings and set environment
-warnings.filterwarnings('ignore', category=UserWarning)
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-
-class ConfigManager:
-    """Configuration management class"""
-    
-    @staticmethod
-    def load_config(config_file: str = 'config.json') -> Dict:
-        try:
-            with open(config_file, 'r') as f:
-                return json.load(f)
-        except FileNotFoundError:
-            return {}
 
-    @staticmethod
-    def save_config(config: Dict, config_file: str = 'config.json') -> None:
-        with open(config_file, 'w') as f:
-            json.dump(config, f, indent=4)
-
-# Example usage
-warnings.warn("This is a user warning", UserWarning)
-
-class SecurityManager:
-    """Security management class"""
-    
-    @staticmethod
-    def validate_token(token: str) -> bool:
-        return bool(token and len(token) >= 40)
+# Suppress warnings
+warnings.filterwarnings('ignore', category='User Warning')
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
-    @staticmethod
-    def sanitize_input(input_str: str) -> str:
-        return urllib.parse.quote(input_str)
+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)
+
+# Configure logging
+    logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    handlers=[
+        logging.FileHandler(log_file),
+        logging.StreamHandler()
+        ])
+    )
+    # 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))
+
+    sys.excepthook = handle_exception
+    return logging.getLogger(__name__)
+
+logger = initialize_environment()
 
 class GitHubAPI:
-    """Enhanced GitHub API handler with caching and retry mechanism"""
+    """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',
-            'User-Agent': 'GitHub-Issue-Manager'
+            'Accept': 'application/vnd.github.v3+json'
         }
         self.base_url = "https://api.github.com"
-        self.session = requests.Session()
-        self.executor = ThreadPoolExecutor(max_workers=4)
 
-    @lru_cache(maxsize=100)
-    def _make_request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
-        """Make HTTP request with retry mechanism"""
-        for attempt in range(MAX_RETRIES):
-            try:
-                response = self.session.request(
-                    method,
-                    f"{self.base_url}/{endpoint}",
-                    headers=self.headers,
-                    timeout=REQUEST_TIMEOUT,
-                    **kwargs
-                )
-                response.raise_for_status()
-                return response
-            except requests.exceptions.RequestException as e:
-                if attempt == MAX_RETRIES - 1:
-                    raise
-                time.sleep(2 ** attempt)  # Exponential backoff
+    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()
+            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 Exception as e:
+            logger.error(f"Error checking rate limit: {str(e)}")
+            return True
 
     def get_repository(self, owner: str, repo: str) -> Dict:
-        """Get repository information with caching"""
-        response = self._make_request('GET', f"repos/{owner}/{repo}")
-        return response.json()
+        """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 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]:
+        """Fetch repository issues"""
+        if not self._check_rate_limit():
+            return []
 
-    async def get_issues_async(self, owner: str, repo: str, state: str = 'open') -> List[Dict]:
-        """Asynchronously fetch repository issues"""
         try:
-            response = await self.executor.submit(
-                self._make_request,
-                'GET',
-                f"repos/{owner}/{repo}/issues",
-                params={'state': state}
-            )
+            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 requests.HTTPError as e:
+            logger.error(f"HTTP error fetching issues: {str(e)}")
+            return []
         except Exception as e:
             logger.error(f"Error fetching issues: {str(e)}")
             return []
 
 class GitHubBot:
-    """Enhanced GitHub bot implementation"""
+    """Main GitHub bot implementation"""
     
     def __init__(self):
         self.github_api = None
-        self.config_manager = ConfigManager()
-        self.security_manager = SecurityManager()
 
-    def initialize_api(self, token: str) -> None:
-        """Initialize GitHub API with validation"""
-        if not self.security_manager.validate_token(token):
-            raise ValueError("Invalid GitHub token")
+    def initialize_api(self, token: str):
+        """Initialize GitHub API with token"""
         self.github_api = GitHubAPI(token)
 
-    async def fetch_issues(self, token: str, username: str, repo: str) -> List[Dict]:
-        """Fetch issues with async support"""
+    def fetch_issues(self, token: str, username: str, repo: str) -> List[Dict]:
+        """Fetch issues from GitHub repository"""
         try:
             self.initialize_api(token)
-            return await self.github_api.get_issues_async(username, repo)
+            return self.github_api.get_issues(username, repo)
         except Exception as e:
             logger.error(f"Error fetching issues: {str(e)}")
             return []
 
-    def resolve_issue(self, token: str, username: str, repo: str, 
-                     issue_number: int, resolution: str, forked_repo: str) -> str:
-        """Enhanced issue resolution with better error handling"""
+    def resolve_issue(self)
+, token: str, username: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
+        """Resolve a GitHub issue and submit PR."""
         try:
             self.initialize_api(token)
-            repo_info = self.github_api.get_repository(username, repo)
-
-            # Create resolution directory if it doesn't exist
-            resolution_dir = Path('resolutions')
-            resolution_dir.mkdir(exist_ok=True)
+            self.github_api.get_repository(username, repo)
 
-            # Save resolution with sanitized content
+            # Create resolution file
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            resolution_file = resolution_dir / f"resolution_{issue_number}_{timestamp}.md"
-            
-            with resolution_file.open('w') as f:
+            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}")
 
-            # Handle git operations with better error checking
-            repo_path = Path('/tmp') / forked_repo.split('/')[-1]
-            if repo_path.exists():
-                shutil.rmtree(repo_path)
-
-            # Clone and setup repository
-            result = subprocess.run(
-                ['git', 'clone', forked_repo],
-                cwd='/tmp',
-                capture_output=True,
-                text=True
-            )
-            if result.returncode != 0:
-                raise RuntimeError(f"Git clone failed: {result.stderr}")
+            # Clone the forked repo
+            subprocess.run(['git', '-C', '/tmp', 'clone', forked_repo])
+
+            # Change to the cloned directory
+            subprocess.run(['cd', '/tmp/' + forked_repo.split('/')[-1]])
+
+            # Assuming manual intervention now
+            answer = input("Apply the fix manually and stage the changes (press ENTER)? ")
+
+            # Commit and push the modifications
+            subprocess.run(['git', 'add', '.'])
+            subprocess.run(['git', 'commit', '-m', f"Resolved issue #{issue_number} ({urllib.parse.quote(resolution)})"])
+            subprocess.run(['git', 'push', 'origin', 'HEAD'])
+
+            # Open Pull Request page
+            webbrowser.open('https://github.com/' + forked_repo.split('/')[-1] + '/compare/master...' + username + ':' + forked_repo.split('/')[-1] + '_resolved_issue_' + str(issue_number))
 
-            # Continue with remaining implementation...
             return f"Resolution saved: {resolution_file}"
 
         except Exception as e:
@@ -246,10 +234,17 @@ custom_css = """
     }
 """
 
-def create_gradio_interface():
-    """Create and configure Gradio interface with custom styling"""
-    bot = GitHubBot()
+def greet(name):
+    return f"Hello {name}!"
 
+def create_gradio_interface():
+    with gr.Blocks() as demo:
+        name = gr.Textbox(label="Name")
+        output = gr.Textbox(label="Output")
+        greet_btn = gr.Button("Greet")
+        greet_btn.click(fn=greet, inputs=name, outputs=output)
+    return demo
+    
     with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
         gr.HTML("""
             <div class="container">
@@ -373,37 +368,9 @@ def signal_handler(signum, frame):
     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)
-
-    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,
-        }
+logger = logging.getLogger(__name__)
 
-        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 = demo.queue()
-        demo.launch(**launch_kwargs)
-
-    except Exception as e:
-        logger.error(f"Error launching application: {str(e)}")
-        raise
-    finally:
-        logger.info("Application shutdown")
+if __name__ == "__main__":
+    demo = create_gradio_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+        logger.info("Launch successful!")