Add history and metrics tabs to Gradio interface

app.py

@@ -5,6 +5,8 @@ from huggingface_hub import login
 import os
 import logging
 from datetime import datetime
+import json
+from typing import List, Dict
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -14,11 +16,25 @@ logger = logging.getLogger(__name__)
 HF_TOKEN = os.getenv("HUGGING_FACE_TOKEN")
 MODEL_NAME = os.getenv("MODEL_NAME", "google/gemma-2b-it")
 
+class Review:
+    def __init__(self, code: str, language: str, suggestions: str):
+        self.code = code
+        self.language = language
+        self.suggestions = suggestions
+        self.timestamp = datetime.now().isoformat()
+        self.response_time = 0.0
+
 class CodeReviewer:
     def __init__(self):
         self.model = None
         self.tokenizer = None
         self.device = "cpu"
+        self.review_history: List[Review] = []
+        self.metrics = {
+            'total_reviews': 0,
+            'avg_response_time': 0.0,
+            'reviews_today': 0
+        }
         self.initialize_model()
         
     def initialize_model(self):
@@ -58,6 +74,7 @@ Code:
     def review_code(self, code: str, language: str) -> str:
         """Perform code review using the model."""
         try:
+            start_time = datetime.now()
             prompt = self.create_review_prompt(code, language)
             
             inputs = self.tokenizer(
@@ -80,12 +97,60 @@ Code:
                 )
             
             response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            return response[len(prompt):].strip()
+            suggestions = response[len(prompt):].strip()
+            
+            # Create review and update metrics
+            end_time = datetime.now()
+            review = Review(code, language, suggestions)
+            review.response_time = (end_time - start_time).total_seconds()
+            self.review_history.append(review)
+            
+            # Update metrics
+            self.update_metrics(review)
+            
+            return suggestions
             
         except Exception as e:
             logger.error(f"Error during code review: {e}")
             return f"Error performing code review: {str(e)}"
 
+    def update_metrics(self, review: Review):
+        """Update metrics with new review."""
+        self.metrics['total_reviews'] += 1
+        
+        # Update average response time
+        total_time = self.metrics['avg_response_time'] * (self.metrics['total_reviews'] - 1)
+        total_time += review.response_time
+        self.metrics['avg_response_time'] = total_time / self.metrics['total_reviews']
+        
+        # Update reviews today
+        today = datetime.now().date()
+        self.metrics['reviews_today'] = sum(
+            1 for r in self.review_history 
+            if datetime.fromisoformat(r.timestamp).date() == today
+        )
+
+    def get_history(self) -> List[Dict]:
+        """Get formatted review history."""
+        return [
+            {
+                'timestamp': r.timestamp,
+                'language': r.language,
+                'code': r.code,
+                'suggestions': r.suggestions,
+                'response_time': f"{r.response_time:.2f}s"
+            }
+            for r in reversed(self.review_history[-10:])  # Last 10 reviews
+        ]
+
+    def get_metrics(self) -> Dict:
+        """Get current metrics."""
+        return {
+            'Total Reviews': self.metrics['total_reviews'],
+            'Average Response Time': f"{self.metrics['avg_response_time']:.2f}s",
+            'Reviews Today': self.metrics['reviews_today']
+        }
+
 # Initialize the reviewer
 reviewer = CodeReviewer()
 
@@ -100,40 +165,97 @@ def review_code_interface(code: str, language: str) -> str:
     except Exception as e:
         return f"Error: {str(e)}"
 
+def get_history_interface() -> str:
+    """Format history for display."""
+    history = reviewer.get_history()
+    if not history:
+        return "No reviews yet."
+    
+    result = ""
+    for review in history:
+        result += f"Time: {review['timestamp']}\n"
+        result += f"Language: {review['language']}\n"
+        result += f"Response Time: {review['response_time']}\n"
+        result += "Code:\n```\n" + review['code'] + "\n```\n"
+        result += "Suggestions:\n" + review['suggestions'] + "\n"
+        result += "-" * 80 + "\n\n"
+    return result
+
+def get_metrics_interface() -> Dict:
+    """Get metrics for display."""
+    return reviewer.get_metrics()
+
 # Create Gradio interface
-iface = gr.Interface(
-    fn=review_code_interface,
-    inputs=[
-        gr.Textbox(
-            lines=10,
-            placeholder="Enter your code here...",
-            label="Code"
-        ),
-        gr.Dropdown(
-            choices=["python", "javascript", "java", "cpp", "typescript", "go", "rust"],
-            value="python",
-            label="Language"
-        )
-    ],
-    outputs=gr.Textbox(
-        label="Review Results",
-        lines=10
-    ),
-    title="Code Review Assistant",
-    description="An automated code review system powered by Gemma-2b that provides intelligent code analysis and suggestions for improvements.",
-    examples=[
-        ["""def add_numbers(a, b):
+with gr.Blocks(theme=gr.themes.Soft()) as iface:
+    gr.Markdown("# Code Review Assistant")
+    gr.Markdown("An automated code review system powered by Gemma-2b")
+    
+    with gr.Tabs():
+        with gr.Tab("Review Code"):
+            with gr.Row():
+                with gr.Column():
+                    code_input = gr.Textbox(
+                        lines=10,
+                        placeholder="Enter your code here...",
+                        label="Code"
+                    )
+                    language_input = gr.Dropdown(
+                        choices=["python", "javascript", "java", "cpp", "typescript", "go", "rust"],
+                        value="python",
+                        label="Language"
+                    )
+                    submit_btn = gr.Button("Submit for Review")
+                with gr.Column():
+                    output = gr.Textbox(
+                        label="Review Results",
+                        lines=10
+                    )
+        
+        with gr.Tab("History"):
+            refresh_history = gr.Button("Refresh History")
+            history_output = gr.Textbox(
+                label="Review History",
+                lines=20,
+                value=get_history_interface()
+            )
+        
+        with gr.Tab("Metrics"):
+            refresh_metrics = gr.Button("Refresh Metrics")
+            metrics_output = gr.JSON(
+                label="Performance Metrics",
+                value=get_metrics_interface()
+            )
+    
+    # Set up event handlers
+    submit_btn.click(
+        review_code_interface,
+        inputs=[code_input, language_input],
+        outputs=output
+    )
+    refresh_history.click(
+        get_history_interface,
+        outputs=history_output
+    )
+    refresh_metrics.click(
+        get_metrics_interface,
+        outputs=metrics_output
+    )
+    
+    # Add example inputs
+    gr.Examples(
+        examples=[
+            ["""def add_numbers(a, b):
     return a + b""", "python"],
-        ["""function calculateSum(numbers) {
+            ["""function calculateSum(numbers) {
     let sum = 0;
     for(let i = 0; i < numbers.length; i++) {
         sum += numbers[i];
     }
     return sum;
 }""", "javascript"]
-    ],
-    theme=gr.themes.Soft()
-)
+        ],
+        inputs=[code_input, language_input]
+    )
 
 # Launch the app
 if __name__ == "__main__":