Update app.py

app.py

@@ -5,6 +5,7 @@ import os
 import time
 from datetime import datetime
 import groq
+import time
 
 # API keys (replace with your keys or use environment variables)
 mistral_api_key = os.getenv("MISTRAL_API_KEY", "gz6lDXokxgR6cLY72oomALWcm7vhjRzQ")
@@ -13,159 +14,79 @@ groq_api_key = os.getenv("GROQ_API_KEY", "gsk_x7oGLO1zSgSVYOWDtGYVWGdyb3FYrWBjaz
 # Initialize Groq client
 groq_client = groq.Client(api_key=groq_api_key)
 
-# Function to call Mistral API
-def call_mistral_api(prompt):
-    url = "https://api.mistral.ai/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {mistral_api_key}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "model": "mistral-medium",
-        "messages": [
-            {"role": "user", "content": prompt}
-        ]
-    }
-    try:
-        response = requests.post(url, headers=headers, json=payload)
-        response.raise_for_status()  # Raise an error for bad status codes
-        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}"
-    except Exception as err:
-        return f"Error: {err}"
-
-# Function to call Groq API
-def call_groq_api(prompt):
-    try:
-        response = groq_client.chat.completions.create(
-            model="llama-3.3-70b-versatile",  # Correct model name
-            messages=[
-                {"role": "user", "content": prompt}
-            ]
-        )
-        return response.choices[0].message.content
-    except Exception as err:
-        st.error(f"Error: {err}")
-        return f"Error: {err}"
+# Function to measure API response time
+def measure_response_time(api_call, *args):
+    start_time = time.time()
+    result = api_call(*args)
+    end_time = time.time()
+    response_time = end_time - start_time
+    return result, response_time
+
+# Function to check confidence level
+def estimate_confidence(response):
+    if "high" in response.lower():
+        return "High"
+    elif "medium" in response.lower():
+        return "Medium"
+    else:
+        return "Low"
 
 # 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 = 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 = 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 = 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 = call_groq_api(rewritten_prompt).strip()
+    # Measure API response time and get responses
+    req_type, time_type = measure_response_time(call_mistral_api, f"Classify as Functional or Non-Functional:\n{requirement}")
+    domain, time_domain = measure_response_time(call_mistral_api, f"Classify domain:\n{requirement}")
+    defects, time_defects = measure_response_time(call_groq_api, f"List major defects:\n{requirement}")
+    rewritten, time_rewritten = measure_response_time(call_groq_api, f"Rewrite requirement:\n{requirement}")
+    
+    # Estimate confidence
+    confidence_type = estimate_confidence(req_type)
+    confidence_domain = estimate_confidence(domain)
+    confidence_defects = estimate_confidence(defects)
+    confidence_rewritten = estimate_confidence(rewritten)
 
     return {
         "Requirement": requirement,
         "Type": req_type,
         "Domain": domain,
         "Defects": defects,
-        "Rewritten": rewritten
+        "Rewritten": rewritten,
+        "Times": {
+            "Type": time_type,
+            "Domain": time_domain,
+            "Defects": time_defects,
+            "Rewritten": time_rewritten
+        },
+        "Confidence": {
+            "Type": confidence_type,
+            "Domain": confidence_domain,
+            "Defects": confidence_defects,
+            "Rewritten": confidence_rewritten
+        }
     }
 
-# Function to generate a PDF report
-def generate_pdf_report(results):
-    pdf = FPDF()
-    pdf.add_page()
-    pdf.set_font("Arial", size=12)
-
-    # Add watermark
-    pdf.set_font("Arial", 'B', 50)
-    pdf.set_text_color(230, 230, 230)  # Light gray color for watermark
-    pdf.rotate(45)  # Rotate the text for watermark effect
-    pdf.text(60, 150, "AI Powered Requirement Analysis")
-    pdf.rotate(0)  # Reset rotation
-
-    # Add title and date/time
-    pdf.set_font("Arial", 'B', 16)
-    pdf.set_text_color(0, 0, 0)  # Black color for title
-    pdf.cell(200, 10, txt="AI Powered Requirement Analysis and Defect Detection", ln=True, align='C')
-    pdf.set_font("Arial", size=12)
-    pdf.cell(200, 10, txt=f"Report Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ln=True, align='C')
-    pdf.ln(10)  # Add some space
-
-    # Add requirements analysis
-    pdf.set_font("Arial", size=12)
-    for i, result in enumerate(results, start=1):
-        if pdf.get_y() > 250:  # If the content is near the bottom of the page
-            pdf.add_page()  # Add a new page
-            pdf.set_font("Arial", 'B', 16)
-            pdf.cell(200, 10, txt="AI Powered Requirement Analysis and Defect Detection", ln=True, align='C')
-            pdf.set_font("Arial", size=12)
-            pdf.cell(200, 10, txt=f"Report Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ln=True, align='C')
-            pdf.ln(10)  # Add some space
-
-        # Add requirement details
-        pdf.set_font("Arial", 'B', 14)
-        pdf.multi_cell(200, 10, txt=f"Requirement R{i}: {result['Requirement']}", align='L')
-        pdf.set_font("Arial", size=12)
-        pdf.multi_cell(200, 10, txt=f"Type: {result['Type']}", align='L')
-        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="-" * 50, align='L')
-        pdf.ln(5)  # Add some space between requirements
-
-    pdf_output = "requirements_report.pdf"
-    pdf.output(pdf_output)
-    return pdf_output
-
 # Streamlit app
 def main():
     st.title("AI Powered Requirement Analysis and Defect Detection")
     st.markdown("**Team Name:** Sadia, Areeba, Rabbia, Tesmia")
-    st.markdown("**Models:** Mistral (Classification & Domain) + Groq (Defects & Rewriting)")
-
-    # Input requirements manually
-    input_text = st.text_area("Enter your requirements (one per line or separated by periods):")
-    requirements = []
-    if input_text:
-        requirements = [req.strip() for req in input_text.replace("\n", ".").split(".") if req.strip()]
+    
+    input_text = st.text_area("Enter requirements (one per line):")
+    requirements = [req.strip() for req in input_text.split("\n") if req.strip()]
 
-    # Analyze requirements
     if st.button("Analyze Requirements"):
         if not requirements:
             st.warning("Please enter requirements.")
         else:
-            results = []
-            for req in requirements:
-                if req.strip():  # Ignore empty lines
-                    results.append(analyze_requirement(req.strip()))
-
-            # Display results
+            results = [analyze_requirement(req) for req in requirements]
             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:** {result['Type']} ({result['Confidence']['Type']} Confidence, {result['Times']['Type']:.2f}s)")
+                st.write(f"**Domain:** {result['Domain']} ({result['Confidence']['Domain']} Confidence, {result['Times']['Domain']:.2f}s)")
+                st.write(f"**Defects:** {result['Defects']} ({result['Confidence']['Defects']} Confidence, {result['Times']['Defects']:.2f}s)")
+                st.write(f"**Rewritten:** {result['Rewritten']} ({result['Confidence']['Rewritten']} Confidence, {result['Times']['Rewritten']:.2f}s)")
                 st.write("---")
 
-            # Generate and download PDF report
-            pdf_report = generate_pdf_report(results)
-            with open(pdf_report, "rb") as f:
-                st.download_button(
-                    label="Download PDF Report",
-                    data=f,
-                    file_name="requirements_report.pdf",
-                    mime="application/pdf"
-                )
-
-# Run the app
 if __name__ == "__main__":
-    main()
+    main()