import os from transformers import Wav2Vec2ForCTC, Wav2Vec2Tokenizer from transformers import AutoTokenizer, DistilBertPreTrainedModel, DistilBertModel, DistilBertTokenizer import torch.nn as nn import torch import shutil from fastapi import FastAPI, File, UploadFile, Form from pydantic import BaseModel from transformers import AutoTokenizer, DistilBertPreTrainedModel, DistilBertModel, DistilBertTokenizer import torch.nn as nn import torch import streamlit as st import soundfile as sf import numpy as np import warnings import librosa import torch from transformers import Wav2Vec2ForCTC, Wav2Vec2Tokenizer import requests import re import tempfile import os import pyarrow as pa import json import joblib import re import nltk from nltk.corpus import words import pickle import sys from sentence_transformers import SentenceTransformer, util from textblob import TextBlob import nltk data_dir = 'nltk_data' # Set the NLTK data path to the local directory nltk.data.path.append(data_dir) ''''''''''''''''''''''''' Skeletal Structure for the Models ''''''''''''''''''''''''''' class DistilBertForRegression(DistilBertPreTrainedModel): def __init__(self, config): super().__init__(config) self.distilbert = DistilBertModel(config) self.pre_classifier = nn.Linear(config.hidden_size, config.hidden_size) self.classifier = nn.Linear(config.hidden_size, 1) self.dropout = nn.Dropout(config.seq_classif_dropout) self.init_weights() def forward(self, input_ids=None, attention_mask=None, head_mask=None, inputs_embeds=None, labels=None): distilbert_output = self.distilbert ( input_ids=input_ids, attention_mask=attention_mask, head_mask=head_mask, inputs_embeds=inputs_embeds, ) hidden_state = distilbert_output[0] # (bs, seq_len, dim) pooled_output = hidden_state[:, 0] # (bs, dim) pooled_output = self.pre_classifier(pooled_output) # (bs, dim) pooled_output = nn.ReLU()(pooled_output) # (bs, dim) pooled_output = self.dropout(pooled_output) # (bs, dim) logits = self.classifier(pooled_output) # (bs, 1) return logits ''''''''''''''' Loading the Pronunciation Model and Tokenizer ''''''''' device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Load the Pronunciation model and tokenizer from the local directory pronunciation_model_dir = 'pronunciation_model' fluency_model_dir = 'fluency_model' print("Loading pronunciation tokenizer from local directory...") pronunciation_tokenizer = Wav2Vec2Tokenizer.from_pretrained(pronunciation_model_dir) print("Loading pronunciation model from local directory...") pronunciation_model = Wav2Vec2ForCTC.from_pretrained(pronunciation_model_dir) # Load the Fluency model and tokenizer from the local directory print("Loading fluency tokenizer from local directory...") fluency_tokenizer = DistilBertTokenizer.from_pretrained(fluency_model_dir) print("Loading fluency model from local directory...") fluency_model = DistilBertForSequenceClassification.from_pretrained(fluency_model_dir) print("Models loaded successfully.") fluency_model.to(device) # device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # Determine the device to use (GPU if available, otherwise CPU) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # Move the models to the appropriate device # pronunciation_model.to(device) # fluency_model.to(device) ''''''''''''''''''''' LOADING THE BIASING MODELS ''''''''''''''' def load_pickle_file(file_path): with open(file_path, 'rb') as file: data = pickle.load(file) return data linreg_fluency = load_pickle_file("fluency_model_biasing.pkl") linreg_pronunciation = load_pickle_file("pronunciation_model_biasing.pkl") '''''''''''''''''''''' Load the Content Relevance and Scoring Model ''''''''''''''' model_dir = 'content_relevance_model' # Load the SentenceTransformer model from the local directory print("Loading SentenceTransformer model from local directory...") model = SentenceTransformer(model_dir) print("Model loaded successfully.") print(linreg_fluency) print(linreg_pronunciation) print(content_relevance_model) import requests from PIL import Image from transformers import BlipProcessor, BlipForConditionalGeneration import torch ''''''''''''''''''''''' IMAGE CAPTIONING MODEL ''''''''''''''''' # Define the directories where the models and processors are saved processor_dir = 'blip_processor' model_dir = 'blip_model' # Load the BlipProcessor from the local directory print("Loading BlipProcessor from local directory...") image_captioning_processor = BlipProcessor.from_pretrained(processor_dir) print("BlipProcessor loaded successfully.") # Load the BlipForConditionalGeneration model from the local directory print("Loading BlipForConditionalGeneration model from local directory...") image_captioning_model = BlipForConditionalGeneration.from_pretrained(model_dir) image_captioning_model.to(device) # Move model to the appropriate device print("BlipForConditionalGeneration model loaded successfully.") ''''''''''''''''''' FUNCTIONS FOR PREPROCESSING ''''''''''''''' async def count_misspelled_words(text): nltk_data_dir = os.path.join(os.getcwd(), 'nltk_data') nltk.data.path.append(nltk_data_dir) english_words = set(words.words()) words_in_text = re.findall(r'\b\w+\b', text.lower()) total_words = len(words_in_text) misspelled = [word for word in words_in_text if word not in english_words] incorrect_count = len(misspelled) return f"{(incorrect_count / total_words * 100):.2f}" async def get_fluency_score(transcription): tokenized_text = fluency_tokenizer(transcription, return_tensors="pt") with torch.no_grad(): output = fluency_model(**tokenized_text) fluency_score = output.item() return round(fluency_score, 2) def download_word_list(): print("Downloading English word list...") url = "https://raw.githubusercontent.com/dwyl/english-words/master/words_alpha.txt" response = requests.get(url) words = set(response.text.split()) print("Word list downloaded.") return words english_words = download_word_list() # Function to count correctly spelled words in text async def count_spelled_words(text, word_list): print("Counting spelled words...") # Split the text into words words = re.findall(r'\b\w+\b', text.lower()) correct = sum(1 for word in words if word in word_list) incorrect = len(words) - correct print("Spelling check complete.") return incorrect, correct # Function to apply spell check to an item (assuming it's a dictionary) async def apply_spell_check(item, word_list): print("Applying spell check...") if isinstance(item, dict): # This is a single item text = item['transcription'] incorrect, correct = await count_spelled_words(text, word_list) item['incorrect_words'] = incorrect item['correct_words'] = correct print("Spell check applied to single item.") return item else: # This is likely a batch texts = item['transcription'] results = [count_spelled_words(text, word_list) for text in texts] incorrect_counts, correct_counts = zip(*results) item = item.append_column('incorrect_words', pa.array(incorrect_counts)) item = item.append_column('correct_words', pa.array(correct_counts)) print("Spell check applied to batch of items.") return item async def get_pronunciation_and_fluency_scores(transcription): count_spelled_words_response, fluency_score = await asyncio.gather( count_spelled_words(transcription, english_words), get_fluency_score(transcription) ) incorrect = count_spelled_words_response[ 0 ] correct = count_spelled_words_response[ 1 ] # Calculate pronunciation score fraction = correct / (incorrect + correct) pronunciation_score = round(fraction * 100, 2) # Calculate fluency score return { "transcription": transcription, "pronunciation_score": pronunciation_score, "fluency_score": fluency_score, "Content Quality and Relevance Score": 0 } def transcribe_audio(audio_path): warnings.filterwarnings("ignore", message="PySoundFile failed. Trying audioread instead.") warnings.filterwarnings("ignore", message="librosa.core.audio.__audioread_load") # Load audio file audio, sample_rate = sf.read(audio_path) # Check if the audio is mono if len(audio.shape) > 1: audio = audio[:, 0] # Resample if needed (Wav2Vec2 expects 16kHz) if sample_rate != 16000: # Simple resampling (less accurate but doesn't require librosa) audio = np.array(audio[::int(sample_rate/16000)]) input_values = pronunciation_tokenizer(audio, return_tensors="pt").input_values.to(device) logits = pronunciation_model(input_values).logits prediction = torch.argmax(logits, dim = -1) transcription = pronunciation_tokenizer.batch_decode(prediction)[0] return transcription.lower() async def content_score( text1: str, text2 : str ): essay_embedding = content_relevance_model.encode( text1 ) summarization_embedding = content_relevance_model.encode( text2 ) relevance_score = float(util.dot_score( essay_embedding, summarization_embedding).cpu()[0][0]) * 100 if(relevance_score >= 40): relevance_score = relevance_score + 30 relevance_score = min( relevance_score , 100 ) relevance_score = max( 0 , relevance_score ) return relevance_score app = FastAPI() @app.post("/pronunciation_fluency_content_scoring/") async def speech_scoring(speech_topic: str = Form(), audio_file: UploadFile = File(...)): ''''''''''''''''''' Get THE RAW TRANSCRIPTION ''''''''''''''''''' # Save the uploaded file to a temporary location temp_file_path = "temp_audio_file.wav" with open(temp_file_path, "wb") as buffer: shutil.copyfileobj(audio_file.file, buffer) # Transcribe the audio file transcription = transcribe_audio(temp_file_path) # Clean up the temporary file os.remove(temp_file_path) print("transcription: " , transcription , "\n\n") ''''''''''''''''''' GET THE PRONUNCIATION AND FLUENCY SCORING ''''''''''''' ''''''''''''''''''' GET THE CONTENT AND RELEVANCE SCORING ''''''''''''' result, relevance_scores, incorrect_words_percentage = await asyncio.gather( get_pronunciation_and_fluency_scores(transcription), content_score(speech_topic, transcription), count_misspelled_words(transcription) ) ''''''''''''''''''' PASS THE RAW OUTPUTS TO THE BIASING MODEL ''''''''''''' base_pronunciation_score = result["pronunciation_score"] base_fluency_score = result["fluency_score"] base_pronunciation_score = float(base_pronunciation_score) base_fluency_score = float(base_fluency_score) incorrect_words_percentage = float(incorrect_words_percentage) print("Base Pronunciation Score:", base_pronunciation_score) print("Base fluency Score:", base_fluency_score) print("Incorrect Words Percentage:", incorrect_words_percentage) final_pronunciation_score = max(0, min(100, linreg_pronunciation.predict(np.array([[base_pronunciation_score, base_fluency_score, incorrect_words_percentage]]))[0])) final_fluency_score = max(0, min(100, linreg_fluency.predict(np.array([[base_pronunciation_score, base_fluency_score, incorrect_words_percentage]]))[0])) result["Content Quality and Relevance Score"] = relevance_scores result["pronunciation_score"] = final_pronunciation_score result["fluency_score"] = final_fluency_score return result def Get_Captions(context: str , image_captioning_model, image_file): # Open and convert the image raw_image = Image.open(image_file.file).convert('RGB') context = "Describe this image, " # Prepare the inputs inputs = image_captioning_processor(raw_image, context, return_tensors="pt") print("Generating the output ") # Generate the caption out = image_captioning_model.generate(**inputs, num_beams=5) # Decode and return the caption caption = image_captioning_processor.decode(out[0], skip_special_tokens=True) return caption # @app.post("/get_image_description/") # async def image_captioning(context: str, image_file: UploadFile = File(...)): # image_caption_text = Get_Captions(context, image_captioning_model, image_file) # return {"image_captions" : context + " " + image_caption_text} @app.post("/image_description_scoring/") async def image_description_scoring( context : str = Form() , audio_file: UploadFile = File(...) ,image_file: UploadFile = File(...) ): ''''''''''''''''''' Get THE RAW TRANSCRIPTION ''''''''''''''''''' # Save the uploaded file to a temporary location temp_file_path = "temp_audio_file.wav" with open(temp_file_path, "wb") as buffer: shutil.copyfileobj(audio_file.file, buffer) # Transcribe the audio file transcription = transcribe_audio(temp_file_path) # Clean up the temporary file os.remove(temp_file_path) image_captions = Get_Captions( context , image_captioning_model , image_file) result, relevance_scores, incorrect_words_percentage = await asyncio.gather( get_pronunciation_and_fluency_scores(transcription), content_score( image_captions , transcription), count_misspelled_words(transcription) ) ''''''''''''''''''' PASS THE RAW OUTPUTS TO THE BIASING MODEL ''''''''''''' base_pronunciation_score = result["pronunciation_score"] base_fluency_score = result["fluency_score"] base_pronunciation_score = float(base_pronunciation_score) base_fluency_score = float(base_fluency_score) incorrect_words_percentage = float(incorrect_words_percentage) print("Base Pronunciation Score:", base_pronunciation_score) print("Base fluency Score:", base_fluency_score) print("Incorrect Words Percentage:", incorrect_words_percentage) final_pronunciation_score = max(0, min(100, linreg_pronunciation.predict(np.array([[base_pronunciation_score, base_fluency_score, incorrect_words_percentage]]))[0])) final_fluency_score = max(0, min(100, linreg_fluency.predict(np.array([[base_pronunciation_score, base_fluency_score, incorrect_words_percentage]]))[0])) print("Base Pronunciation Score:", base_pronunciation_score) print("Base fluency Score:", base_fluency_score) print("Incorrect Words Percentage:", incorrect_words_percentage) final_pronunciation_score = max(0, min(100, linreg_pronunciation.predict(np.array([[base_pronunciation_score, base_fluency_score, incorrect_words_percentage]]))[0])) final_fluency_score = max(0, min(100, linreg_fluency.predict(np.array([[base_pronunciation_score, base_fluency_score, incorrect_words_percentage]]))[0])) result["Content Quality and Relevance Score"] = relevance_scores result["pronunciation_score"] = final_pronunciation_score result["fluency_score"] = final_fluency_score return result # @app.post("/transcribe_audio/") # async def transcribe( audio_file: UploadFile = File(...) ): # temp_file_path = "temp_audio_file.wav" # with open(temp_file_path, "wb") as buffer: # shutil.copyfileobj(audio_file.file, buffer) # # Transcribe the audio file # transcription = transcribe_audio(temp_file_path) # return {"transcription" : transcription} import string import asyncio async def is_valid_summary_format(summary: str) -> bool: # CHECK IF THE SUMMARY CONTAINS ONLY BULLET POINTS if '-' in summary or '*' in summary: return True # CHECK IF THE SUMMARY CONSISTS ONLY OF VERY SHORT SENTENCES sentences = re.split(r'[.!?]', summary) short_sentences = sum(len(sentence.split()) <= 70 for sentence in sentences if sentence.strip()) print(" Short Sentences: " , short_sentences ) # CONSIDER IT A VALID FORMAT IF MORE THAN HALF OF THE SENTENCES ARE SHORT return short_sentences >= len(sentences) / 2 async def form_score_summary(summary: str) -> float: # CONVERT THE SUMMARY TO UPPERCASE summary_upper = summary.upper() # REMOVE PUNCTUATION summary_clean = re.sub(r'[^\w\s]', '', summary_upper) # COUNT THE NUMBER OF WORDS word_count = len(summary_clean.split()) # CHECK IF THE SUMMARY FORMAT IS VALID valid_format = is_valid_summary_format(summary) print("\n\n word count: ", word_count, " valid_format: ", valid_format) # CALCULATE SCORE BASED ON WORD COUNT AND FORMAT if valid_format: if 45 <= word_count <= 75: if word_count < 50: score = 50 + (word_count - 45) * (50 / 5) # Gradual increase from 50 elif word_count <= 75: score = 100 # Best score range else: score = 100 - (word_count - 70) * (50 / 5) # Gradual decrease from 100 else: score = 0 # Worst score if word count is out of acceptable range else: score = 0 # Worst score if format is invalid # CLAMP SCORE BETWEEN 0 AND 100 score = float( score ) return max(0.0, min(100.0, score)) async def grammar_score(text: str) -> int: # Create a TextBlob object blob = TextBlob(text) # Check for grammatical errors errors = 0 for sentence in blob.sentences: if sentence.correct() != sentence: errors += 1 print(" \n\n Number of grammatical errors: " , errors ) errors *= 5 result = 100 - errors return max( 0 , result) async def vocabulary_score(text: str) -> float: # Create a TextBlob object blob = TextBlob(text) # Extract words from the text words = blob.words # Count the total words and correctly spelled words total_words = len(words) correctly_spelled = sum(1 for word in words if word == TextBlob(word).correct()) # Calculate the percentage of correctly spelled words if total_words == 0: return 0.0 # Avoid division by zero if there are no words percentage_correct = (correctly_spelled / total_words) * 100 percentage_correct = min( percentage_correct , 100) percentage_correct = max( 0 , percentage_correct ) percentage_correct = round( percentage_correct , 2 ) return percentage_correct @app.post("/summarization_scoring/") async def summarization_score( essay : str = Form() , summarization : str = Form() ): content_score_result, form_score_result, grammar_score_result, vocabulary_score_result = await asyncio.gather( content_score(essay, summarization), form_score_summary(summarization), grammar_score(summarization), vocabulary_score(summarization) ) return { "Content Score: " : content_score_result, "Form Score: " : form_score_result, "Grammar Score: " : grammar_score_result, "Vocabulary Score: " : vocabulary_score_result, "Overall Summarization Score: " : round( (content_score_result + form_score_result + grammar_score_result + vocabulary_score_result) / 4 , 2) } ''' transitional words can significantly contribute to the development, structure, and coherence of a text. Development: Transitional words help to show how ideas build upon each other and progress throughout the essay. They can introduce new points, provide examples, or signal a shift in focus. Structure: Transitional words help to organize the text by indicating relationships between ideas. They can show cause and effect, compare and contrast, or signal a sequence of events. Coherence: Transitional words help to create a smooth flow between sentences and paragraphs, making the text easier to understand and follow. They can clarify connections between ideas and prevent the text from feeling disjointed. ''' addition_transitional_words = [ "and", "also", "too", "in addition", "furthermore", "moreover", "besides", "likewise", "similarly", "equally important", "not to mention", "as well as", "what's more", "on top of that", "to boot", "in the same way", "by the same token", "similarly", "likewise", "in a similar vein", "correspondingly", "at the same time", "concurrently", "simultaneously", "not only... but also", "both... and", "as well", "and then", "and so forth", "and so on" ] contrast_transitional_words = [ "but", "however", "nevertheless", "nonetheless", "on the other hand", "on the contrary", "in contrast", "conversely", "although", "though", "even though", "despite", "in spite of", "regardless of", "while", "whereas", "yet", "still", "even so", "even if", "at the same time", "by the same token", "equally", "in common", "similarly", "just like", "just as", "as well as", "resemble", "equally", "in common", "by the same token" ] cause_effect_transitional_words = [ "because", "since", "as", "due to", "owing to", "thanks to", "on account of", "as a result", "consequently", "therefore", "hence", "thus", "so", "accordingly", "for this reason", "as a consequence", "in consequence", "in that case", "that being the case", "for that reason", "as a result of", "because of", "on account of", "owing to", "due to", "thanks to" ] time_transitional_words = [ "first", "second", "third", "next", "then", "after", "before", "later", "earlier", "previously", "subsequently", "following", "meanwhile", "simultaneously", "at the same time", "concurrently", "in the meantime", "in the interim", "afterwards", "thereafter", "finally", "lastly", "ultimately", "in conclusion", "to conclude", "in summary", "to sum up" ] emphasis_transitional_words = [ "indeed", "in fact", "certainly", "assuredly", "without a doubt", "undoubtedly", "unquestionably", "undeniably", "absolutely", "positively", "emphatically", "decisively", "strongly", "forcefully", "with conviction", "with certainty", "with assurance", "without hesitation", "without question", "without fail", "without doubt" ] example_transitional_words = [ "for example", "for instance", "such as", "like", "as an illustration", "to illustrate", "to demonstrate", "to exemplify", "namely", "specifically", "in particular", "particularly", "especially" ] conclusion_transitional_words = [ "in conclusion", "to conclude", "in summary", "to sum up", "finally", "lastly", "ultimately", "therefore", "hence", "thus", "so", "accordingly", "as a result", "consequently" ] transition_between_sections_transitional_words = [ "in the following section", "moving on to", "now", "let's explore", "turning our attention to", "to delve deeper", "we will now examine", "next", "at this point", "at this juncture", "furthermore", "moreover", "in addition" ] miscellaneous_transition_words_list = [ # Clarification "in other words", "that is to say", "namely", "to put it another way", "in simpler terms", "to clarify", "to explain further", "to elaborate", "to be more specific", "to be more exact", # Concession "admittedly", "granted", "of course", "naturally", "it is true that", "it must be admitted that", "it cannot be denied that", "it goes without saying that", # Digression "by the way", "incidentally", "aside from that", "apart from that", # Repetition "again", "once again", "still", "further", "furthermore", "moreover", "in addition" ] contrast_within_sentence_transitional_words = [ "but", "however", "nevertheless", "nonetheless", "on the other hand", "in contrast", "conversely", "although", "though", "even though", "despite", "in spite of", "regardless of", "while", "whereas", "yet", "still", "even so", "even if" ] comparison_transitional_words = [ "similarly", "likewise", "in the same way", "equally", "in common", "by the same token", "just like", "just as", "as well as", "resemble" ] cause_and_effect_within_sentence_transitional_words = [ "because", "since", "as", "due to", "owing to", "thanks to", "on account of", "as a result", "consequently", "therefore", "hence", "thus", "so", "accordingly", "for this reason", "as a consequence", "in consequence", "in that case", "that being the case", "for that reason", "as a result of", "because of", "on account of", "owing to", "due to", "thanks to" ] emphasis_within_sentence_transitional_words = [ "indeed", "in fact", "certainly", "assuredly", "without a doubt", "undoubtedly", "unquestionably", "undeniably", "absolutely", "positively", "emphatically", "decisively", "strongly", "forcefully", "with conviction", "with certainty", "with assurance", "without hesitation", "without question", "without fail", "without doubt" ] concession_digression_repetition_transitional_words = [ # Concession "admittedly", "granted", "of course", "naturally", "it is true that", "it must be admitted that", "it cannot be denied that", "it goes without saying that", # Digression "by the way", "incidentally", "aside from that", "apart from that", # Repetition "again", "once again", "still", "further", "furthermore", "moreover", "in addition" ] async def dsc_score( essay: str ): # Normalize the essay essay_lower = essay.lower() # Helper function to count occurrences of transitional words def count_transitional_words(word_list): return sum(essay_lower.count(word) for word in word_list) # Calculate counts for each type of transitional word list addition_count = count_transitional_words(addition_transitional_words) contrast_count = count_transitional_words(contrast_transitional_words) cause_effect_count = count_transitional_words(cause_effect_transitional_words) time_count = count_transitional_words(time_transitional_words) emphasis_count = count_transitional_words(emphasis_transitional_words) example_count = count_transitional_words(example_transitional_words) conclusion_count = count_transitional_words(conclusion_transitional_words) transition_between_sections_count = count_transitional_words(transition_between_sections_transitional_words) misc_count = count_transitional_words(miscellaneous_transition_words_list) contrast_within_sentence_count = count_transitional_words(contrast_within_sentence_transitional_words) comparison_count = count_transitional_words(comparison_transitional_words) cause_and_effect_within_sentence_count = count_transitional_words(cause_and_effect_within_sentence_transitional_words) emphasis_within_sentence_count = count_transitional_words(emphasis_within_sentence_transitional_words) concession_digression_repetition_count = count_transitional_words(concession_digression_repetition_transitional_words) # Calculate total transitional word count total_transitional_count = ( addition_count + contrast_count + cause_effect_count + time_count + emphasis_count + example_count + conclusion_count + transition_between_sections_count + misc_count + contrast_within_sentence_count + comparison_count + cause_and_effect_within_sentence_count + emphasis_within_sentence_count + concession_digression_repetition_count ) print("\n\n\n Total Transitional Words Count: " , total_transitional_count ) words = essay.split() word_count = len(words) transitional_words_percentage = round( ( total_transitional_count / ( word_count * 1.00) ) * 100 , 2 ) print("]n\n\n transitional_words_percentage: " , transitional_words_percentage) ''' Since a transition_words_percentage of 10% is considered as the ideal percentage of transitional words in an essay, we are deducting points with respect to how much is it deviating from its ideal percentage value. This have proven to be powerful to determine the Development, Structure and Coherence in essays ''' return 100 - abs( transitional_words_percentage - 10 ) def is_capitalized(text: str) -> bool: """Check if the entire text is in capital letters.""" return text.isupper() def contains_punctuation(text: str) -> bool: """Check if the text contains any punctuation.""" return bool(re.search(r'[.,!?;:]', text)) def is_bullet_points(text: str) -> bool: """Check if the text consists only of bullet points or very short sentences.""" sentences = text.split('\n') bullet_points = any(line.strip().startswith('-') for line in sentences) short_sentences = sum(len(sentence.split()) <= 2 for sentence in sentences if sentence.strip()) return bullet_points or short_sentences > len(sentences) / 2 async def form_score_essay(essay: str) -> float: # REMOVE PUNCTUATION AND COUNT WORDS word_count = len(re.findall(r'\b\w+\b', essay)) # CHECK ESSAY FORMAT is_capital = is_capitalized(essay) has_punctuation = contains_punctuation(essay) bullet_points_or_short = is_bullet_points(essay) # CALCULATE SCORE if 200 <= word_count <= 300 and has_punctuation and not is_capital and not bullet_points_or_short: score = 100.0 # BEST SCORE elif (120 <= word_count <= 199 or 301 <= word_count <= 380) and has_punctuation and not is_capital and not bullet_points_or_short: score = 50.0 # AVERAGE SCORE else: score = 0.0 # WORST SCORE return score @app.post("/essay_scoring/") async def essay_score( prompt : str = Form() , essay : str = Form() ): content_score_result, form_score_result, dsc_score_result, grammar_score_result = await asyncio.gather( content_score( prompt , essay ), form_score_essay( essay ), dsc_score( essay ), grammar_score( essay ) ) print( essay ) return { "Content Score: " : content_score_result, "Form Score: " : form_score_result, "DSC Score: " : dsc_score_result, "Grammar Score: " : grammar_score_result, "Overall Essay Score" : ( content_score_result + form_score_result + dsc_score_result + grammar_score_result) / 4.0 }