app.py

import streamlit as st
import random
import spacy
import requests
from bs4 import BeautifulSoup
import re
import spacy
import language_tool_python
import json
from gradio_client import Client

API_URL = "https://api-inference.huggingface.co/models/facebook/bart-large-mnli"
headers = {"Authorization": "Bearer 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"}

def query(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()

# Define the grammar_sense function
def grammar_sense(sentence):
    sense = query({
        "inputs": sentence,
        "parameters": {"candidate_labels": ["Make Sense", "Not Make Sense"]},
    })
    grammar = query({
        "inputs": sentence,
        "parameters": {"candidate_labels": ["Correct Grammar", "Incorrect Grammar"]},
    })
    objects = ["Sense", "Grammar"]
    ans = []
    for i in objects:
        if i == "Sense":
            response_data = json.loads(json.dumps(sense))
            labels = response_data['labels']
            scores = response_data['scores']
            index_of_highest_score = scores.index(max(scores))
            highest_score_label = labels[index_of_highest_score]
            ans.append(highest_score_label)
        else:
            response_data = json.loads(json.dumps(grammar))
            labels = response_data['labels']
            scores = response_data['scores']
            index_of_highest_score = scores.index(max(scores))
            highest_score_label = labels[index_of_highest_score]
            ans.append(highest_score_label)

    if not 'Not' in ans[0] and ans[1] == 'Correct Grammar':
        return True
    else:
        return False

# Initialize LanguageTool
tool = language_tool_python.LanguageToolPublicAPI('en-US')

# Define the Streamlit app
st.title("NLP Testing and Scoring App")

# Ask for the topic at the start
topic = st.text_input("Enter a topic:")

# Web scraping and text cleaning
entity = "Florida"  # You can replace this with the user's topic input
if topic:
    entity = topic  # Use the user's input as the entity

prefix = "https://wiki.kidzsearch.com/wiki/"
page = requests.get(f'{prefix}{entity}')
res = BeautifulSoup(page.content, 'html.parser')

text = [i.get_text() for i in res.find_all('p')]

cleaned_text = ' '.join(text)
cleaned_text = re.sub(r'[^a-zA-Z0-9.,]', ' ', cleaned_text)
paragraphs = [p.strip() for p in re.split(r'\n', cleaned_text) if p.strip()]

# Process text using SpaCy
nlp = spacy.load("en_core_web_sm")
doc = nlp(cleaned_text)

sentences = [sent.text for sent in doc.sents]

# Combine sentences into paragraphs
paragraphs = [f"{sentences[i]} {sentences[i + 1]}" if i + 1 < len(sentences) else sentences[i] for i in range(0, len(sentences), 2)]
class SubjectiveTest:

    def __init__(self, data, noOfQues):
        self.summary = data
        self.noOfQues = noOfQues
        self.nlp = spacy.load("en_core_web_sm")

    def adjust_question_pattern(self, entity_label, topic_placeholder=True):
        question_patterns = {
            "PERSON": ["Who is {entity}?", "Tell me about {entity}", "What do you know about {entity}"],
            "ORG": ["What is {entity}?", "Tell me about {entity}", "What do you know about {entity}"],
            "GPE": ["Tell me about {entity}", "What do you know about {entity}", "Where is {entity}"],
            "MONEY": ["How much is {entity}?", "Tell me the value of {entity}"],
            "DATE": ["Why was {entity} important?"],
            # Add more entity-label to question-pattern mappings as needed
        }

        if topic_placeholder:
            for key in question_patterns:
                question_patterns[key] = [pattern + " {topic}" for pattern in question_patterns[key]]

        return question_patterns.get(entity_label, "Explain")

    def generate_test(self, topic=None):
        doc = self.nlp(self.summary)
        question_answer_dict = dict()

        for sentence in doc.sents:
            for ent in sentence.ents:
                entity_label = ent.label_
                entity_text = ent.text
                question_patterns = self.adjust_question_pattern(entity_label, "")
                for pattern in question_patterns:
                    question = pattern.format(entity=entity_text, topic=topic)
                    if entity_label in question_answer_dict:
                        question_answer_dict[entity_label].append(question)
                    else:
                        question_answer_dict[entity_label] = [question]

        questions = []

        for entity_label, entity_questions in question_answer_dict.items():
            entity_questions = entity_questions[:self.noOfQues]
            if "Explain" in entity_questions:
                continue
            else:
                questions.extend(entity_questions)

        return questions

with st.form("quiz_form"):
    # Create a button to initiate quiz generation
    generate_quiz = st.form_submit_button("Generate Quiz")

if generate_quiz:
    st.write("Generating the quiz...")
    data = ' '.join(paragraphs)
    noOfQues = 5

    subjective_generator = SubjectiveTest(data, noOfQues)
    questions = subjective_generator.generate_test(topic)  # Use the user's input topic here

    # Filter out invalid and empty questions
    x = 0
    while x > len(questions):
        for i in questions:
            if len(i) == 1:
                questions.pop(x)
                x = x + 1
            else:
                x = x + 1
    # Ensure you have valid questions
    if not questions:
        st.write("No valid questions to process.")
    else:
        answers = {}  # Dictionary to store answers

        # Use the filtered questions in your code
        for i, question in enumerate(questions):
            res = st.text_input(f'Q{i + 1}: {question}')  # Get user input for each question
            answers[f'Q{i + 1}'] = res  # Store the user's answer

        scores = []
        client = Client("https://billbojangeles2000-zephyr-7b-alpha-chatbot-karki.hf.space/")

        question_list = subjective_generator.generate_test(topic)  # Define 'questions' here
        questions = []
        for i, question in enumerate(question_list):
            if (question != "") and (len(tool.check(question)) == 0) and (grammar_sense(question)):
                questions.append(f"Question: {question}")

        for i, question in enumerate(questions):
            res = answers[f'Q{i + 1}']
            if res:
                result = client.predict(
                    f'What would you rate this answer to the question: "{question}" as a percentage? Here is the answer: {res}. Make sure to write your answer as "Score" and then write your score of the response.',
                    0.9,
                    256,
                    0.9,
                    1.2,
                    api_name="/chat"
                )
                pattern = r'(\d+)%'
                match = re.search(pattern, result)
                if match:
                    score = int(match.group(1))
                    scores.append(score)
                else:
                    scores.append(85)

        def calculate_average(numbers):
            if not numbers:
                return 0  # Return 0 for an empty list to avoid division by zero.

            total = sum(numbers)
            average = total / len(numbers)
            return average

        # Calculate and display the average score
        average_score = calculate_average(scores)
        st.write(f'Your average score is {average_score}')