app.py

import streamlit as st
import requests
from fpdf import FPDF
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")
groq_api_key = os.getenv("GROQ_API_KEY", "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")

# Initialize Groq client
groq_client = groq.Client(api_key=groq_api_key)

# 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):
    # 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,
        "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
        }
    }

# Streamlit app
def main():
    st.title("AI Powered Requirement Analysis and Defect Detection")
    st.markdown("**Team Name:** Sadia, Areeba, Rabbia, Tesmia")
    
    input_text = st.text_area("Enter requirements (one per line):")
    requirements = [req.strip() for req in input_text.split("\n") if req.strip()]

    if st.button("Analyze Requirements"):
        if not requirements:
            st.warning("Please enter requirements.")
        else:
            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']} ({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("---")

if __name__ == "__main__":
    main()