File size: 4,629 Bytes
5a44472
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import streamlit as st
import random
import spacy
import requests
from bs4 import BeautifulSoup
import re
import spacy
import language_tool_python

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

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

# Web scraping and text cleaning
entity = "Canada"
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}", "Explain {entity}", "What do you know about {entity}"],
            "ORG": ["What is {entity}?", "Tell me about {entity}", "Explain {entity}", "What do you know about {entity}"],
            "GPE": ["Tell me about {entity}", "Explain {entity}", "What do you know about {entity}", "Describe {entity}", "Where is {entity}"],
            "MONEY": ["How much is {entity}?", "Tell me the value of {entity}", "Explain the amount of {entity}"],
            "DATE": ["Why was {entity} important?", "Explain what happened on {entity}"],
            # 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 {entity} {topic}"])

    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, topic is not None)
                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]
            questions.extend(entity_questions)

        return questions

# Example usage
data = ' '.join(paragraphs)
noOfQues = 5

subjective_generator = SubjectiveTest(data, noOfQues)
question_list = subjective_generator.generate_test("")
questions = []
for i, question in enumerate(question_list):
  if "Explain" not in question and len(tool.check(question)) == 0 and grammar_sense(question) == "Make Sense":
    questions.append(f"Question: {question}")

scores = []

# Now, add a Streamlit UI for input and displaying scores
st.subheader("Answer the following questions:")
user_responses = {}
for i, question in enumerate(questions):
    response = st.text_area(f"Question {i + 1}", key=f"response_{i}")
    user_responses[f"response_{i}"] = response

if st.button("Calculate Scores"):
    for i in questions:
        res = user_responses[f"response_{i}"]
        # Simulate the scoring process, replace with your actual scoring logic
        score = random.randint(0, 100)
        scores.append(score)

    x = 0
    new_scores = []
    for i in scores:
        if i == 'N/A':
            scores.pop(x)
            scores.append(85)
            x = x + 1
        else:
            x = x + 1

    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

    st.subheader(f'Your average score is {calculate_average(scores)}')