app.py

import os
import gradio as gr
from transformers import pipeline
import spacy
import subprocess
import nltk
from nltk.corpus import wordnet
from spellchecker import SpellChecker
from fastapi import FastAPI
from pydantic import BaseModel
import uvicorn

# Initialize FastAPI app
api_app = FastAPI()

# Initialize the English text classification pipeline for AI detection
pipeline_en = pipeline(task="text-classification", model="Hello-SimpleAI/chatgpt-detector-roberta")

# Initialize the spell checker
spell = SpellChecker()

# Ensure necessary NLTK data is downloaded
nltk.download('wordnet')
nltk.download('omw-1.4')

# Ensure the SpaCy model is installed
try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
    nlp = spacy.load("en_core_web_sm")

# Define request models for FastAPI
class TextRequest(BaseModel):
    text: str

# Function to predict the label and score for English text (AI Detection)
def predict_en(text):
    res = pipeline_en(text)[0]
    return res['label'], res['score']

# Function to remove redundant and meaningless words
def remove_redundant_words(text):
    doc = nlp(text)
    meaningless_words = {"actually", "basically", "literally", "really", "very", "just"}
    filtered_text = [token.text for token in doc if token.text.lower() not in meaningless_words]
    return ' '.join(filtered_text)

# Function to capitalize the first letter of sentences and proper nouns
def capitalize_sentences_and_nouns(text):
    doc = nlp(text)
    corrected_text = []

    for sent in doc.sents:
        sentence = []
        for token in sent:
            if token.i == sent.start:  # First word of the sentence
                sentence.append(token.text.capitalize())
            elif token.pos_ == "PROPN":  # Proper noun
                sentence.append(token.text.capitalize())
            else:
                sentence.append(token.text)
        corrected_text.append(' '.join(sentence))

    return '\n'.join(corrected_text)  # Preserve paragraphs by joining sentences with newline

# Function to force capitalization of the first letter of every sentence
def force_first_letter_capital(text):
    sentences = text.split(". ")  # Split by period to get each sentence
    capitalized_sentences = [sentence[0].capitalize() + sentence[1:] if sentence else "" for sentence in sentences]
    return ". ".join(capitalized_sentences)

# Function to correct tense errors in a sentence
def correct_tense_errors(text):
    doc = nlp(text)
    corrected_text = []
    for token in doc:
        if token.pos_ == "VERB" and token.dep_ in {"aux", "auxpass"}:
            lemma = wordnet.morphy(token.text, wordnet.VERB) or token.text
            corrected_text.append(lemma)
        else:
            corrected_text.append(token.text)
    return ' '.join(corrected_text)

# Function to correct singular/plural errors
def correct_singular_plural_errors(text):
    doc = nlp(text)
    corrected_text = []
    
    for token in doc:
        if token.pos_ == "NOUN":
            if token.tag_ == "NN":  # Singular noun
                if any(child.text.lower() in ['many', 'several', 'few'] for child in token.head.children):
                    corrected_text.append(token.lemma_ + 's')
                else:
                    corrected_text.append(token.text)
            elif token.tag_ == "NNS":  # Plural noun
                if any(child.text.lower() in ['a', 'one'] for child in token.head.children):
                    corrected_text.append(token.lemma_)
                else:
                    corrected_text.append(token.text)
        else:
            corrected_text.append(token.text)
    
    return ' '.join(corrected_text)

# Function to correct spelling errors
def correct_spelling(text):
    words = text.split()
    corrected_words = []
    for word in words:
        corrected_word = spell.correction(word)
        corrected_words.append(corrected_word)
    return ' '.join(corrected_words)

# Function to rephrase text and replace words with their synonyms while maintaining form
def rephrase_with_synonyms(text):
    doc = nlp(text)
    rephrased_text = []

    for token in doc:
        pos_tag = None
        if token.pos_ == "NOUN":
            pos_tag = wordnet.NOUN
        elif token.pos_ == "VERB":
            pos_tag = wordnet.VERB
        elif token.pos_ == "ADJ":
            pos_tag = wordnet.ADJ
        elif token.pos_ == "ADV":
            pos_tag = wordnet.ADV
        
        if pos_tag:
            synonyms = wordnet.synsets(token.lemma_, pos=pos_tag)
            if synonyms:
                synonym = synonyms[0].lemmas()[0].name()
                if token.pos_ == "VERB":
                    if token.tag_ == "VBG":  # Present participle
                        synonym = synonym + 'ing'
                    elif token.tag_ in {"VBD", "VBN"}:  # Past tense or past participle
                        synonym = synonym + 'ed'
                    elif token.tag_ == "VBZ":  # Third-person singular present
                        synonym = synonym + 's'
                rephrased_text.append(synonym)
            else:
                rephrased_text.append(token.text)
        else:
            rephrased_text.append(token.text)

    return ' '.join(rephrased_text)

# Function to paraphrase and correct grammar with enhanced accuracy
def paraphrase_and_correct(text):
    # Remove meaningless or redundant words first
    cleaned_text = remove_redundant_words(text)
    
    # Capitalize sentences and nouns
    paraphrased_text = capitalize_sentences_and_nouns(cleaned_text)
    
    # Ensure first letter of each sentence is capitalized
    paraphrased_text = force_first_letter_capital(paraphrased_text)
    
    # Apply grammatical corrections
    paraphrased_text = correct_singular_plural_errors(paraphrased_text)
    paraphrased_text = correct_tense_errors(paraphrased_text)
    
    # Rephrase with synonyms while maintaining grammatical forms
    paraphrased_text = rephrase_with_synonyms(paraphrased_text)
    
    # Correct spelling errors
    paraphrased_text = correct_spelling(paraphrased_text)
    
    return paraphrased_text

# FastAPI Endpoint for AI detection
@api_app.post("/ai-detection")
async def ai_detection(request: TextRequest):
    label, score = predict_en(request.text)
    return {"label": label, "score": score}

# FastAPI Endpoint for paraphrasing and grammar correction
@api_app.post("/paraphrase")
async def paraphrase(request: TextRequest):
    corrected_text = paraphrase_and_correct(request.text)
    return {"corrected_text": corrected_text}

# Gradio app setup with two tabs
with gr.Blocks() as demo:
    with gr.Tab("AI Detection"):
        t1 = gr.Textbox(lines=5, label='Text')
        button1 = gr.Button("🤖 Predict!")
        label1 = gr.Textbox(lines=1, label='Predicted Label 🎃')
        score1 = gr.Textbox(lines=1, label='Prob')

        # Connect the prediction function to the button
        button1.click(fn=predict_en, inputs=t1, outputs=[label1, score1])

    with gr.Tab("Paraphrasing & Grammar Correction"):
        t2 = gr.Textbox(lines=5, label='Enter text for paraphrasing and grammar correction')
        button2 = gr.Button("🔄 Paraphrase and Correct")
        result2 = gr.Textbox(lines=10, label='Corrected Text', placeholder="The corrected text will appear here...")

        # Connect the paraphrasing and correction function to the button
        button2.click(fn=paraphrase_and_correct, inputs=t2, outputs=result2)

# Launch the Gradio app
demo.launch(share=True)

# Run the FastAPI app in a separate thread if needed
if __name__ == "__main__":
    uvicorn.run(api_app, host="0.0.0.0", port=8000)