Update app.py

app.py

@@ -17,7 +17,7 @@ import urllib.parse
 import http.client
 
 # Suppress warnings
-warnings.filterwarnings('ignore', category='User Warning')
+warnings.filterwarnings('ignore', category=User Warning)  # Corrected here
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
 def initialize_environment():
@@ -27,16 +27,17 @@ def initialize_environment():
     for directory in directories:
         os.makedirs(directory, exist_ok=True)
 
-# Configure logging
+    # Configure logging
+    log_file = f"logs/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
     logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    handlers=[
-        logging.FileHandler(log_file),
-        logging.StreamHandler()
+        level=logging.INFO,
+        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):
@@ -114,9 +115,7 @@ class GitHubBot:
     """Main GitHub bot implementation"""
     
     def __init__(self):
-        self.github_api = None
-
-    def initialize_api(self, token: str):
+        self.github_api = None def initialize_api(self, token: str):
         """Initialize GitHub API with token"""
         self.github_api = GitHubAPI(token)
 
@@ -143,13 +142,13 @@ class GitHubBot:
                 f.write(f"# Resolution for Issue #{issue_number}\n\n{resolution}")
 
             # Clone the forked repo
-            subprocess.run(['git', '-C', '/tmp', 'clone', forked_repo])
+            subprocess.run(['git', 'clone', forked_repo, '/tmp/' + forked_repo.split('/')[-1]])
 
             # Change to the cloned directory
-            subprocess.run(['cd', '/tmp/' + forked_repo.split('/')[-1]])
+            os.chdir('/tmp/' + forked_repo.split('/')[-1])
 
             # Assuming manual intervention now
-            answer = input("Apply the fix manually and stage the changes (press ENTER)? ")
+            input("Apply the fix manually and stage the changes (press ENTER)? ")
 
             # Commit and push the modifications
             subprocess.run(['git', 'add', '.'])
@@ -234,17 +233,10 @@ custom_css = """
     }
 """
 
-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
-    
+    """Create and configure Gradio interface with custom styling"""
+    bot = GitHub Bot()
+
     with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
         gr.HTML("""
             <div class="container">
@@ -257,7 +249,7 @@ def create_gradio_interface():
                 label="GitHub Token",
                 placeholder="Enter your GitHub token",
                 type="password",
-                elem_classes=" input input-bordered input-primary"
+                elem_classes="input input-bordered input-primary"
             )
             github_username = gr.Textbox(
                 label="Repository Owner",
@@ -368,9 +360,238 @@ def signal_handler(signum, frame):
     cleanup()
     sys.exit(0)
 
-logger = logging.getLogger(__name__)
-
 if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-        logger.info("Launch successful!")
+    # 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,
+        }
+
+        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")
+from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
+
+class HuggingFaceModel:
+    """Class to handle Hugging Face model loading and predictions"""
+    
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+        self.model = None
+        self.tokenizer = None
+        self.load_model()
+
+    def load_model(self):
+        """Load the Hugging Face model and tokenizer"""
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
+            logger.info(f"Model {self.model_name} loaded successfully.")
+        except Exception as e:
+            logger.error(f"Error loading model {self.model_name}: {str(e)}")
+            raise
+
+    def predict(self, text: str) -> Dict:
+        """Make a prediction using the loaded model"""
+        try:
+            inputs = self.tokenizer(text, return_tensors="pt")
+            outputs = self.model(**inputs)
+            predictions = outputs.logits.argmax(dim=-1).item()
+            logger.info(f"Prediction made for input: {text} with result: {predictions}")
+            return {"prediction": predictions}
+        except Exception as e:
+            logger.error(f"Error making prediction: {str(e)}")
+            return {"error": str(e)}
+
+# Update the Gradio interface to include model loading and prediction
+def create_gradio_interface():
+    """Create and configure Gradio interface with custom styling"""
+    bot = GitHubBot()
+    hf_model = None  # Initialize Hugging Face model variable
+
+    with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
+        # Existing Gradio components...
+
+        model_name = gr.Textbox(
+            label="Hugging Face Model Name",
+            placeholder="Enter the model name (e.g., 'distilbert-base-uncased')",
+            elem_classes="input input-bordered input-primary"
+        )
+
+        load_model_button = gr.Button(
+            "Load Model",
+            elem_classes="button button-primary"
+        )
+
+        prediction_text = gr.Textbox(
+            label="Input Text for Prediction",
+            placeholder="Enter text to classify...",
+            elem_classes="textarea textarea-primary"
+        )
+
+        predict_button = gr.Button(
+            "Make Prediction",
+            elem_classes="button button-success"
+        )
+
+        output_prediction = gr.Textbox(
+            label="Prediction Output",
+            interactive=False,
+            elem_classes="output-area"
+        )
+
+        # Load model handler
+        def load_model_handler(model_name_input):
+            nonlocal hf_model
+            try:
+                hf_model = HuggingFaceModel(model_name_input)
+                return f"Model {model_name_input} loaded successfully."
+            except Exception as e:
+                return f"Error loading model: {str(e)}"
+
+        # Prediction handler
+        def predict_handler(input_text):
+            if hf_model is None:
+                return "Model not loaded. Please load a model first."
+            result = hf_model.predict(input_text)
+            return result
+
+        # Connect components
+        load_model_button.click(
+            load_model_handler,
+            inputs=[model_name],
+            outputs=[output_prediction]
+        )
+
+        predict_button.click(
+            predict_handler,
+            inputs=[prediction_text],
+            outputs=[output_prediction]
+        )
+
+    return demo
+
+from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
+
+class HuggingFaceModel:
+    """Class to handle Hugging Face model loading and predictions"""
+    
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+        self.model = None
+        self.tokenizer = None
+        self.load_model()
+
+    def load_model(self):
+        """Load the Hugging Face model and tokenizer"""
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
+            logger.info(f"Model {self.model_name} loaded successfully.")
+        except Exception as e:
+            logger.error(f"Error loading model {self.model_name}: {str(e)}")
+            raise
+
+    def predict(self, text: str) -> Dict:
+        """Make a prediction using the loaded model"""
+        try:
+            inputs = self.tokenizer(text, return_tensors="pt")
+            outputs = self.model(**inputs)
+            predictions = outputs.logits.argmax(dim=-1).item()
+            logger.info(f"Prediction made for input: {text} with result: {predictions}")
+            return {"prediction": predictions}
+        except Exception as e:
+            logger.error(f"Error making prediction: {str(e)}")
+            return {"error": str(e)}
+
+# Update the Gradio interface to include model loading and prediction
+def create_gradio_interface():
+    """Create and configure Gradio interface with custom styling"""
+    bot = GitHubBot()
+    hf_model = None  # Initialize Hugging Face model variable
+
+    with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
+        # Existing Gradio components...
+
+        model_name = gr.Textbox(
+            label="Hugging Face Model Name",
+            placeholder="Enter the model name (e.g., 'distilbert-base-uncased')",
+            elem_classes="input input-bordered input-primary"
+        )
+
+        load_model_button = gr.Button(
+            "Load Model",
+            elem_classes="button button-primary"
+        )
+
+        prediction_text = gr.Textbox(
+            label="Input Text for Prediction",
+            placeholder="Enter text to classify...",
+            elem_classes="textarea textarea-primary"
+        )
+
+        predict_button = gr.Button(
+            "Make Prediction",
+            elem_classes="button button-success"
+        )
+
+        output_prediction = gr.Textbox(
+            label="Prediction Output",
+            interactive=False,
+            elem_classes="output-area"
+        )
+
+        # Load model handler
+        def load_model_handler(model_name_input):
+            nonlocal hf_model
+            try:
+                hf_model = HuggingFaceModel(model_name_input)
+                return f"Model {model_name_input} loaded successfully."
+            except Exception as e:
+                return f"Error loading model: {str(e)}"
+
+        # Prediction handler
+        def predict_handler(input_text):
+            if hf_model is None:
+                return "Model not loaded. Please load a model first."
+            result = hf_model.predict(input_text)
+            return result
+
+        # Connect components
+        load_model_button.click(
+            load_model_handler,
+            inputs=[model_name],
+            outputs=[output_prediction]
+        )
+
+        predict_button.click(
+            predict_handler,
+            inputs=[prediction_text],
+            outputs=[output_prediction]
+        )
+
+    return demo