Hugging Face's logo

Spaces:
iisadia
/
Requirements
Sleeping

App Files Community
Requirements
File size: 4,905 Bytes 
fc8383a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ce64498
fc8383a
 
 
ce64498
 
fc8383a
ce64498
 
fc8383a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
import gradio as gr
import requests
from fpdf import FPDF
import pdfplumber

# Mistral API key (replace with your key)
API_KEY = "gz6lDXokxgR6cLY72oomALWcm7vhjzQ"
MISTRAL_API_URL = "https://api.mistral.ai/v1/chat/completions"

# Function to call Mistral API
def call_mistral_api(prompt):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": "mistral-medium",
        "messages": [
            {"role": "user", "content": prompt}
        ]
    }
    response = requests.post(MISTRAL_API_URL, headers=headers, json=payload)
    if response.status_code == 200:
        return response.json()['choices'][0]['message']['content']
    else:
        return f"Error: {response.status_code}, {response.text}"

# Function to analyze a single requirement
def analyze_requirement(requirement):
    # Detect requirement type
    type_prompt = f"Classify the following requirement as Functional or Non-Functional:\n\n{requirement}\n\nType:"
    req_type = call_mistral_api(type_prompt)

    # Identify stakeholders
    stakeholders_prompt = f"Identify the stakeholders for the following requirement:\n\n{requirement}\n\nStakeholders:"
    stakeholders = call_mistral_api(stakeholders_prompt)

    # Classify domain
    domain_prompt = f"Classify the domain for the following requirement (e.g., Bank, Healthcare, etc.):\n\n{requirement}\n\nDomain:"
    domain = call_mistral_api(domain_prompt)

    # Detect defects
    defects_prompt = f"Detect any defects in the following requirement (e.g., Ambiguity, Incompleteness, etc.):\n\n{requirement}\n\nDefects:"
    defects = call_mistral_api(defects_prompt)

    # Rewrite requirement
    rewrite_prompt = f"Rewrite the following requirement in a simpler form:\n\n{requirement}\n\nSimplified Requirement:"
    rewritten = call_mistral_api(rewrite_prompt)

    return {
        "Requirement": requirement,
        "Type": req_type,
        "Stakeholders": stakeholders,
        "Domain": domain,
        "Defects": defects,
        "Rewritten": rewritten
    }

# Function to process multiple requirements
def process_requirements(input_text, uploaded_file):
    requirements = []

    # If a file is uploaded, extract text from the PDF
    if uploaded_file:
        with pdfplumber.open(uploaded_file) as pdf:
            for page in pdf.pages:
                requirements.extend(page.extract_text().split("\n"))

    # If text input is provided, split into individual requirements
    if input_text:
        requirements.extend(input_text.split("\n"))

    # Analyze each requirement
    results = []
    for req in requirements:
        if req.strip():  # Ignore empty lines
            results.append(analyze_requirement(req.strip()))

    return results

# Function to generate a PDF report
def generate_pdf_report(results):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", size=12)

    for result in results:
        pdf.cell(200, 10, txt=f"Requirement: {result['Requirement']}", ln=True)
        pdf.cell(200, 10, txt=f"Type: {result['Type']}", ln=True)
        pdf.cell(200, 10, txt=f"Stakeholders: {result['Stakeholders']}", ln=True)
        pdf.cell(200, 10, txt=f"Domain: {result['Domain']}", ln=True)
        pdf.cell(200, 10, txt=f"Defects: {result['Defects']}", ln=True)
        pdf.cell(200, 10, txt=f"Rewritten: {result['Rewritten']}", ln=True)
        pdf.cell(200, 10, txt="-" * 50, ln=True)

    pdf_output = "requirements_report.pdf"
    pdf.output(pdf_output)
    return pdf_output

# Gradio interface
def app_interface(input_text, uploaded_file):
    results = process_requirements(input_text, uploaded_file)
    pdf_report = generate_pdf_report(results)

    # Display results in a clean format
    output_text = ""
    for result in results:
        output_text += f"Requirement: {result['Requirement']}\n"
        output_text += f"Type: {result['Type']}\n"
        output_text += f"Stakeholders: {result['Stakeholders']}\n"
        output_text += f"Domain: {result['Domain']}\n"
        output_text += f"Defects: {result['Defects']}\n"
        output_text += f"Rewritten: {result['Rewritten']}\n"
        output_text += "-" * 50 + "\n\n"

    return output_text, pdf_report

# Gradio app
title = "Requirement Analysis App"
description = """
This app analyzes software requirements using the Mistral model. 
You can either enter requirements manually or upload a PDF file containing requirements.
"""
team_name = "Team Innovators"

interface = gr.Interface(
    fn=app_interface,
    inputs=[
        gr.Textbox(label="Enter Requirements (one per line)"),
        gr.File(label="Upload PDF File (optional)")
    ],
    outputs=[
        gr.Textbox(label="Analysis Results"),
        gr.File(label="Download PDF Report")
    ],
    title=title,
    description=description,
    theme="soft"
)

# Add team name to the interface
interface.launch()