Update app.py

app.py

@@ -1,3 +1,4 @@
+
 import streamlit as st
 import requests
 from fpdf import FPDF
@@ -5,8 +6,6 @@ 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")
@@ -17,7 +16,6 @@ groq_client = groq.Client(api_key=groq_api_key)
 
 # Function to call Mistral API
 def call_mistral_api(prompt):
-    start_time = time.time()
     url = "https://api.mistral.ai/v1/chat/completions"
     headers = {
         "Authorization": f"Bearer {mistral_api_key}",
@@ -32,22 +30,18 @@ def call_mistral_api(prompt):
     try:
         response = requests.post(url, headers=headers, json=payload)
         response.raise_for_status()  # Raise an error for bad status codes
-        end_time = time.time()
-        speed = end_time - start_time
-        content = response.json()['choices'][0]['message']['content']
-        return content, speed
+        return response.json()['choices'][0]['message']['content']
     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
+        return f"HTTP Error: {err}"
     except Exception as err:
-        return f"Error: {err}", 0
+        return f"Error: {err}"
 
 # Function to call Groq API
 def call_groq_api(prompt):
-    start_time = time.time()
     try:
         response = groq_client.chat.completions.create(
             model="llama-3.3-70b-versatile",  # Correct model name
@@ -55,52 +49,35 @@ def call_groq_api(prompt):
                 {"role": "user", "content": prompt}
             ]
         )
-        end_time = time.time()
-        speed = end_time - start_time
-        content = response.choices[0].message.content
-        return content, speed
+        return response.choices[0].message.content
     except Exception as err:
         st.error(f"Error: {err}")
-        return f"Error: {err}", 0
+        return f"Error: {err}"
 
 # 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 = call_mistral_api(type_prompt)
-    req_type = req_type.strip()
+    req_type = call_mistral_api(type_prompt).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 = call_mistral_api(domain_prompt)
-    domain = domain.strip()
+    domain = call_mistral_api(domain_prompt).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 = call_groq_api(defects_prompt)
-    defects = defects.strip()
+    defects = call_groq_api(defects_prompt).strip()
 
     rewritten_prompt = f"""Rewrite the following requirement in 1-2 sentences to address the defects:\n\n{requirement}\n\nRewritten:"""
-    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
+    rewritten = call_groq_api(rewritten_prompt).strip()
 
     return {
         "Requirement": requirement,
         "Type": req_type,
         "Domain": domain,
         "Defects": defects,
-        "Rewritten": rewritten,
-        "Total_Speed": total_speed
+        "Rewritten": rewritten
     }
 
-# 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()
@@ -141,7 +118,6 @@ 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"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
 
@@ -167,41 +143,19 @@ def main():
             st.warning("Please enter requirements.")
         else:
             results = []
-            total_speed = 0
             for req in requirements:
                 if req.strip():  # Ignore empty lines
-                    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)
+                    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("---")
 
             # Generate and download PDF report
             pdf_report = generate_pdf_report(results)
@@ -215,4 +169,4 @@ def main():
 
 # Run the app
 if __name__ == "__main__":
-    main()
+    main()