Update app.py

app.py

@@ -17,21 +17,16 @@ import torch
 import spaces
 from accelerate import Accelerator
 
-warnings.filterwarnings('ignore', category=UserWarning, module='__main__')
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-
-# Example user inputs for input and output directories
-input_directory = 'input'
-output_directory = 'output'
-
-@spaces.GPU
-def initialize_environment(input_file, output_directory):
-    """Initialize application environment and configurations"""
-    directories = ['logs', 'resolutions', 'repos', input_file, output_directory]
-    for directory in directories:
-        os.makedirs(directory, exist_ok=True)
-
-    log_file = f"logs/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+# Constants
+INPUT_DIRECTORY = 'input'
+OUTPUT_DIRECTORY = 'output'
+LOGS_DIRECTORY = 'logs'
+RESOLUTIONS_DIRECTORY = 'resolutions'
+REPOS_DIRECTORY = 'repos'
+
+# 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',
@@ -40,21 +35,18 @@ def initialize_environment(input_file, output_directory):
             logging.StreamHandler()
         ]
     )
-
-    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 = None
+# Set up environment
+@spaces.GPU
+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)
+    return initialize_logger()
 
+# GitHub API handler
 class GitHubAPI:
-    """GitHub API handler with rate limiting and error handling"""
-
     def __init__(self, token: str):
         self.token = token
         self.headers = {
@@ -64,7 +56,6 @@ class GitHubAPI:
         self.base_url = "https://api.github.com"
 
     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()
@@ -84,7 +75,6 @@ class GitHubAPI:
             return True
 
     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()
@@ -97,7 +87,6 @@ class GitHubAPI:
             raise
 
     def get_issues(self, owner: str, repo: str, state: str = 'open') -> List[Dict]:
-        """Fetch repository issues"""
         if not self._check_rate_limit():
             return []
 
@@ -106,25 +95,19 @@ class GitHubAPI:
             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 []
 
+# GitHub Bot
 class GitHubBot:
-    """Main GitHub bot implementation"""
-
     def __init__(self):
         self.github_api = None
 
     def initialize_api(self, token: str):
-        """Initialize GitHub API with token"""
         self.github_api = GitHubAPI(token)
 
     def fetch_issues(self, token: str, owner: str, repo: str) -> List[Dict]:
-        """Fetch issues from GitHub repository"""
         try:
             self.initialize_api(token)
             return self.github_api.get_issues(owner, repo)
@@ -133,14 +116,13 @@ class GitHubBot:
             return []
 
     def resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
-        """Resolve a GitHub issue and submit PR."""
         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/resolution_{issue_number}_{timestamp}.md"
+            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}")
@@ -238,7 +220,6 @@ custom_css = """
 """
 
 def create_gradio_interface(input_file, output_directory):
-    """Create and configure Gradio interface with custom styling"""
     bot = GitHubBot()
 
     with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
@@ -343,10 +324,10 @@ def create_gradio_interface(input_file, output_directory):
 
     return demo
 
+# Cleanup function
 def cleanup():
-    """Cleanup function for graceful shutdown"""
     try:
-        temp_dirs = ['repos']
+        temp_dirs = [REPOS_DIRECTORY]
         for dir_name in temp_dirs:
             if os.path.exists(dir_name):
                 shutil.rmtree(dir_name)
@@ -354,8 +335,8 @@ def cleanup():
     except Exception as e:
         print(f"Error during cleanup: {str(e)}")
 
+# Signal handler
 def signal_handler(signum, frame):
-    """Handle termination signals"""
     logger.info(f"Received signal {signum}")
     cleanup()
     sys.exit(0)
@@ -366,11 +347,12 @@ if __name__ == "__main__":
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
 
-    input_file = "path/to/input/file"
-    output_directory = "path/to/output/directory"
+    input_file = INPUT_DIRECTORY
+    output_directory = OUTPUT_DIRECTORY
 
     # Initialize logger
     logger = initialize_environment(input_file, output_directory)
 
+    # Create Gradio interface
     demo = create_gradio_interface(input_file, output_directory)
     demo.launch()