Update app.py

app.py

@@ -5,6 +5,8 @@ import os
 import time
 from datetime import datetime
 import groq
+import pandas as pd
+import matplotlib.pyplot as plt
 
 # API keys (replace with your keys or use environment variables)
 mistral_api_key = os.getenv("MISTRAL_API_KEY", "gz6lDXokxgR6cLY72oomALWcm7vhjRzQ")
@@ -33,16 +35,15 @@ def call_mistral_api(prompt):
         end_time = time.time()
         speed = end_time - start_time
         content = response.json()['choices'][0]['message']['content']
-        confidence = len(content.split())  # Simulate confidence with response length
-        return content, speed, confidence
+        return content, speed
     except requests.exceptions.HTTPError as err:
         if response.status_code == 429:  # Rate limit exceeded
             st.warning("Rate limit exceeded. Please wait a few seconds and try again.")
             time.sleep(5)  # Wait for 5 seconds before retrying
             return call_mistral_api(prompt)  # Retry the request
-        return f"HTTP Error: {err}", 0, 0
+        return f"HTTP Error: {err}", 0
     except Exception as err:
-        return f"Error: {err}", 0, 0
+        return f"Error: {err}", 0
 
 # Function to call Groq API
 def call_groq_api(prompt):
@@ -57,48 +58,49 @@ def call_groq_api(prompt):
         end_time = time.time()
         speed = end_time - start_time
         content = response.choices[0].message.content
-        confidence = len(content.split())  # Simulate confidence with response length
-        return content, speed, confidence
+        return content, speed
     except Exception as err:
         st.error(f"Error: {err}")
-        return f"Error: {err}", 0, 0
+        return f"Error: {err}", 0
 
 # Function to analyze a single requirement using both models
 def analyze_requirement(requirement):
     # Use Mistral for classification and domain identification
     type_prompt = f"Classify the following requirement as Functional or Non-Functional in one word:\n\n{requirement}\n\nType:"
-    req_type, type_speed, type_confidence = call_mistral_api(type_prompt)
+    req_type, type_speed = call_mistral_api(type_prompt)
     req_type = req_type.strip()
 
     domain_prompt = f"Classify the domain for the following requirement in one word (e.g., E-commerce, Education, etc.):\n\n{requirement}\n\nDomain:"
-    domain, domain_speed, domain_confidence = call_mistral_api(domain_prompt)
+    domain, domain_speed = call_mistral_api(domain_prompt)
     domain = domain.strip()
 
     # Use Groq for defect analysis and rewriting
     defects_prompt = f"""List ONLY the major defects in the following requirement (e.g., Ambiguity, Incompleteness, etc.) in 1-2 words each:\n\n{requirement}\n\nDefects:"""
-    defects, defects_speed, defects_confidence = call_groq_api(defects_prompt)
+    defects, defects_speed = call_groq_api(defects_prompt)
     defects = defects.strip()
 
     rewritten_prompt = f"""Rewrite the following requirement in 1-2 sentences to address the defects:\n\n{requirement}\n\nRewritten:"""
-    rewritten, rewritten_speed, rewritten_confidence = call_groq_api(rewritten_prompt)
+    rewritten, rewritten_speed = call_groq_api(rewritten_prompt)
     rewritten = rewritten.strip()
 
+    # Calculate total speed for this requirement
+    total_speed = type_speed + domain_speed + defects_speed + rewritten_speed
+
     return {
         "Requirement": requirement,
         "Type": req_type,
         "Domain": domain,
         "Defects": defects,
         "Rewritten": rewritten,
-        "Type_Speed": type_speed,
-        "Type_Confidence": type_confidence,
-        "Domain_Speed": domain_speed,
-        "Domain_Confidence": domain_confidence,
-        "Defects_Speed": defects_speed,
-        "Defects_Confidence": defects_confidence,
-        "Rewritten_Speed": rewritten_speed,
-        "Rewritten_Confidence": rewritten_confidence
+        "Total_Speed": total_speed
     }
 
+# Function to calculate accuracy (placeholder logic)
+def calculate_accuracy(results):
+    # Placeholder logic: Assume 80% accuracy for demonstration
+    # Replace this with actual logic if you have correct answers
+    return 80.0  # Return accuracy as a percentage
+
 # Function to generate a PDF report
 def generate_pdf_report(results):
     pdf = FPDF()
@@ -139,14 +141,7 @@ def generate_pdf_report(results):
         pdf.multi_cell(200, 10, txt=f"Domain: {result['Domain']}", align='L')
         pdf.multi_cell(200, 10, txt=f"Defects: {result['Defects']}", align='L')
         pdf.multi_cell(200, 10, txt=f"Rewritten: {result['Rewritten']}", align='L')
-        pdf.multi_cell(200, 10, txt=f"Type Speed: {result['Type_Speed']:.2f}s", align='L')
-        pdf.multi_cell(200, 10, txt=f"Type Confidence: {result['Type_Confidence']}", align='L')
-        pdf.multi_cell(200, 10, txt=f"Domain Speed: {result['Domain_Speed']:.2f}s", align='L')
-        pdf.multi_cell(200, 10, txt=f"Domain Confidence: {result['Domain_Confidence']}", align='L')
-        pdf.multi_cell(200, 10, txt=f"Defects Speed: {result['Defects_Speed']:.2f}s", align='L')
-        pdf.multi_cell(200, 10, txt=f"Defects Confidence: {result['Defects_Confidence']}", align='L')
-        pdf.multi_cell(200, 10, txt=f"Rewritten Speed: {result['Rewritten_Speed']:.2f}s", align='L')
-        pdf.multi_cell(200, 10, txt=f"Rewritten Confidence: {result['Rewritten_Confidence']}", align='L')
+        pdf.multi_cell(200, 10, txt=f"Total Speed: {result['Total_Speed']:.2f}s", align='L')
         pdf.multi_cell(200, 10, txt="-" * 50, align='L')
         pdf.ln(5)  # Add some space between requirements
 
@@ -172,27 +167,41 @@ def main():
             st.warning("Please enter requirements.")
         else:
             results = []
+            total_speed = 0
             for req in requirements:
                 if req.strip():  # Ignore empty lines
-                    results.append(analyze_requirement(req.strip()))
-
-            # Display results
-            st.subheader("Analysis Results")
-            for i, result in enumerate(results, start=1):
-                st.write(f"### Requirement R{i}: {result['Requirement']}")
-                st.write(f"**Type:** {result['Type']}")
-                st.write(f"**Domain:** {result['Domain']}")
-                st.write(f"**Defects:** {result['Defects']}")
-                st.write(f"**Rewritten:** {result['Rewritten']}")
-                st.write(f"**Type Speed:** {result['Type_Speed']:.2f}s")
-                st.write(f"**Type Confidence:** {result['Type_Confidence']}")
-                st.write(f"**Domain Speed:** {result['Domain_Speed']:.2f}s")
-                st.write(f"**Domain Confidence:** {result['Domain_Confidence']}")
-                st.write(f"**Defects Speed:** {result['Defects_Speed']:.2f}s")
-                st.write(f"**Defects Confidence:** {result['Defects_Confidence']}")
-                st.write(f"**Rewritten Speed:** {result['Rewritten_Speed']:.2f}s")
-                st.write(f"**Rewritten Confidence:** {result['Rewritten_Confidence']}")
-                st.write("---")
+                    result = analyze_requirement(req.strip())
+                    results.append(result)
+                    total_speed += result["Total_Speed"]
+
+            # Calculate accuracy (placeholder logic)
+            accuracy = calculate_accuracy(results)
+
+            # Display total speed and accuracy
+            st.subheader("Performance Metrics")
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Speed", f"{total_speed:.2f} seconds")
+            with col2:
+                st.metric("Accuracy", f"{accuracy:.2f}%")
+
+            # Visualize metrics
+            st.subheader("Visualization")
+            metrics_data = {
+                "Metric": ["Total Speed", "Accuracy"],
+                "Value": [total_speed, accuracy]
+            }
+            df = pd.DataFrame(metrics_data)
+
+            # Bar chart
+            fig, ax = plt.subplots()
+            ax.bar(df["Metric"], df["Value"], color=["blue", "green"])
+            ax.set_ylabel("Value")
+            ax.set_title("Performance Metrics")
+            st.pyplot(fig)
+
+            # Table
+            st.table(df)
 
             # Generate and download PDF report
             pdf_report = generate_pdf_report(results)