Update app.py

app.py

@@ -6,12 +6,10 @@ from prometheus_client import start_http_server, Counter, Histogram
 import threading
 import psutil
 import random
-from transformers import pipeline, AutoModelForTokenClassification
+from transformers import pipeline
 
-# Load the model and its configuration
-model_name = "Sevixdd/roberta-base-finetuned-ner" 
-ner_pipeline = pipeline("ner", model=model_name)
-model = AutoModelForTokenClassification.from_pretrained(model_name)  # Load full model
+# Load the model
+ner_pipeline = pipeline("ner", model="Sevixdd/roberta-base-finetuned-ner")
 
 # --- Prometheus Metrics Setup ---
 REQUEST_COUNT = Counter('gradio_request_count', 'Total number of requests')
@@ -21,35 +19,93 @@ REQUEST_LATENCY = Histogram('gradio_request_latency_seconds', 'Request latency i
 logging.basicConfig(filename="chat_log.txt", level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # --- Queue and Metrics ---
-chat_queue = Queue() 
+chat_queue = Queue()  # Define chat_queue globally
 
 # --- Chat Function with Monitoring ---
 def chat_function(message, history):
-    # ... (Chat function remains the same) ...
-
-# --- Gradio Interface with Background Image and Tabs ---
-    with gr.Blocks(css="""
-    body {
-        background-image: url("stag.jpeg"); 
-        background-size: cover; 
-        background-repeat: no-repeat;
-    }
-    """, title="PLOD Filtered with Monitoring") as demo:
-        with gr.Tab("Chat"):
-            gr.Markdown("## Chat with the Bot")
-            chatbot = gr.ChatInterface(fn=chat_function)
-    
-        with gr.Tab("Model Properties"):
-            gr.Markdown("## Model Information")
-            gr.Textbox(label="Model Name", value=model_name, interactive=False)
-            gr.Textbox(label="Model Type", value=model.config.model_type, interactive=False)
-            gr.Number(label="Number of Parameters", value=model.num_parameters(), interactive=False)
-    
-        # ... other tabs (Performance Metrics, Infrastructure, Logs) ...
-    
-        # ... (rest of the code for update functions and background threads)
-    
-    # Launch the app
+    with REQUEST_LATENCY.time():
+        REQUEST_COUNT.inc()
+        try:
+            start_time = time.time()
+            chat_queue.put(message)
+            logging.info(f"User: {message}")
+
+            ner_result = ner_pipeline(message)
+            response = f"Response from NER model: {ner_result}"
+            logging.info(f"Bot: {response}")
+
+            time.sleep(random.uniform(0.5, 2.5))  # Simulate processing time
+
+            chat_queue.get()
+            return response
+        except Exception as e:
+            logging.error(f"Error in chat processing: {e}")
+            return "An error occurred. Please try again."
+
+# --- Gradio Interface with Background Image and Three Windows ---
+with gr.Blocks(css="""
+body {
+    background-image: url("stag.jpeg"); 
+    background-size: cover; 
+    background-repeat: no-repeat;
+}
+""", title="PLOD Filtered with Monitoring") as demo:  # Load CSS for background image
+    with gr.Tab("Chat"):
+        gr.Markdown("## Chat with the Bot")
+        chatbot = gr.ChatInterface(fn=chat_function)
+
+    with gr.Tab("Performance Metrics"):
+        request_count_display = gr.Number(label="Request Count", value=0)
+        avg_latency_display = gr.Number(label="Avg. Response Time (s)", value=0)
+
+    with gr.Tab("Infrastructure"):
+        cpu_usage_display = gr.Number(label="CPU Usage (%)", value=0)
+        mem_usage_display = gr.Number(label="Memory Usage (%)", value=0)
+
+    with gr.Tab("Logs"):
+        logs_display = gr.Textbox(label="Logs", lines=10)  # Increased lines for better visibility
+
+    # --- Update Functions ---
+    def update_metrics(request_count_display, avg_latency_display):
+        while True:
+            request_count = REQUEST_COUNT._value.get()
+            latency_samples = REQUEST_LATENCY.collect()[0].samples
+            avg_latency = sum(s.value for s in latency_samples) / len(latency_samples) if latency_samples else 0
+
+            request_count_display.value = request_count
+            avg_latency_display.value = round(avg_latency, 2)
+
+            time.sleep(5)  # Update every 5 seconds
+
+    def update_usage(cpu_usage_display, mem_usage_display):
+        while True:
+            cpu_usage_display.value = psutil.cpu_percent()
+            mem_usage_display.value = psutil.virtual_memory().percent
+            time.sleep(5)
+
+    def update_logs(logs_display):
+        while True:
+            with open("chat_log.txt", "r") as log_file:
+                logs = log_file.readlines()
+                logs_display.value = "".join(logs[-10:])  # Display last 10 lines
+            time.sleep(1)  # Update every 1 second
+
+    # --- Start Threads ---
+    threading.Thread(target=start_http_server, args=(8000,), daemon=True).start()
+    threading.Thread(target=update_metrics, args=(request_count_display, avg_latency_display), daemon=True).start()
+    threading.Thread(target=update_usage, args=(cpu_usage_display, mem_usage_display), daemon=True).start()
+    threading.Thread(target=update_logs, args=(logs_display,), daemon=True).start()
+
+    # --- Simulate Chat Interactions ---
+    def simulate_interactions():
+        messages = ["Hello bot!", "What's your name?", "Tell me a joke.", "Who are you?"]
+        for msg in messages:
+            chat_function(msg, [])
+            time.sleep(random.uniform(1, 5))  # Random interval between messages
+
+    threading.Thread(target=simulate_interactions, daemon=True).start()  # Start simulation
+
+# Launch the app
 demo.launch(share=True)
 
 
@@ -58,6 +114,19 @@ demo.launch(share=True)
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+