app.py

import os
import gradio as gr
from transformers import pipeline
import spacy
import subprocess
import json
import nltk
from nltk.corpus import wordnet, stopwords
from spellchecker import SpellChecker
import re
import random
import string

# Ensure necessary NLTK data is downloaded
def download_nltk_resources():
    try:
        nltk.download('punkt')
        nltk.download('stopwords')
        nltk.download('averaged_perceptron_tagger')
        nltk.download('averaged_perceptron_tagger_eng')
        nltk.download('wordnet')
        nltk.download('omw-1.4')
        nltk.download('punkt_tab')

    except Exception as e:
        print(f"Error downloading NLTK resources: {e}")

# Call the download function
download_nltk_resources()

top_words = set(stopwords.words("english"))

# Path to the thesaurus file
thesaurus_file_path = 'en_thesaurus.jsonl'  # Ensure the file path is correct

# Function to load the thesaurus into a dictionary
def load_thesaurus(file_path):
    thesaurus_dict = {}
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            for line in file:
                entry = json.loads(line.strip())
                word = entry.get("word")
                synonyms = entry.get("synonyms", [])
                if word:
                    thesaurus_dict[word] = synonyms
    except Exception as e:
        print(f"Error loading thesaurus: {e}")
    
    return thesaurus_dict

# Load the thesaurus
synonym_dict = load_thesaurus(thesaurus_file_path)

# Words and POS tags we don't want to replace
exclude_tags = {'PRP', 'PRP$', 'MD', 'VBZ', 'VBP', 'VBD', 'VBG', 'VBN', 'TO', 'IN', 'DT', 'CC'}
exclude_words = {'is', 'am', 'are', 'was', 'were', 'have', 'has', 'do', 'does', 'did', 'will', 'shall', 'should', 'would', 'could', 'can', 'may', 'might'}

# 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 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")

# Function to predict the label and score for English text (AI Detection)
def predict_en(text):
    try:
        res = pipeline_en(text)[0]
        return res['label'], res['score']
    except Exception as e:
        return f"Error during AI detection: {e}"

# Function to remove plagiarism
def plagiarism_remover(word):
    if word.lower() in top_words or word.lower() in exclude_words or word in string.punctuation:
        return word
    
    # Check for synonyms in the custom thesaurus
    synonyms = synonym_dict.get(word.lower(), set())
    
    # If no synonyms found in the custom thesaurus, use WordNet
    if not synonyms:
        for syn in wordnet.synsets(word):
            for lemma in syn.lemmas():
                if "_" not in lemma.name() and lemma.name().isalpha() and lemma.name().lower() != word.lower():
                    synonyms.add(lemma.name())

    pos_tag_word = nltk.pos_tag([word])[0]
    
    if pos_tag_word[1] in exclude_tags:
        return word
    
    filtered_synonyms = [syn for syn in synonyms if nltk.pos_tag([syn])[0][1] == pos_tag_word[1]]

    if not filtered_synonyms:
        return word

    synonym_choice = random.choice(filtered_synonyms)

    if word.istitle():
        return synonym_choice.title()
    return synonym_choice

# 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 fix spacing before punctuation
def fix_punctuation_spacing(text):
    words = text.split(' ')
    cleaned_words = []
    punctuation_marks = {',', '.', "'", '!', '?', ':'}

    for word in words:
        if cleaned_words and word and word[0] in punctuation_marks:
            cleaned_words[-1] += word
        else:
            cleaned_words.append(word)

    return ' '.join(cleaned_words).replace(' ,', ',').replace(' .', '.').replace(" '", "'") \
                                    .replace(' !', '!').replace(' ?', '?').replace(' :', ':')

# Function to fix possessives like "Earth's"
def fix_possessives(text):
    return re.sub(r'(\w)\s\'\s?s', r"\1's", 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:
                sentence.append(token.text.capitalize())
            elif token.pos_ == "PROPN":
                sentence.append(token.text.capitalize())
            else:
                sentence.append(token.text)
        corrected_text.append(' '.join(sentence))

    return ' '.join(corrected_text)

# Function to force capitalization of the first letter of every sentence and ensure full stops
def force_first_letter_capital(text):
    sentences = re.split(r'(?<=\w[.!?])\s+', text)
    capitalized_sentences = []
    
    for sentence in sentences:
        if sentence:
            capitalized_sentence = sentence[0].capitalize() + sentence[1:]
            if not re.search(r'[.!?]$', capitalized_sentence):
                capitalized_sentence += '.'
            capitalized_sentences.append(capitalized_sentence)
    
    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 check and correct article errors
def correct_article_errors(text):
    doc = nlp(text)
    corrected_text = []
    for token in doc:
        if token.text in ['a', 'an']:
            next_token = token.nbor(1)
            if token.text == "a" and next_token.text[0].lower() in "aeiou":
                corrected_text.append("an")
            elif token.text == "an" and next_token.text[0].lower() not in "aeiou":
                corrected_text.append("a")
            else:
                corrected_text.append(token.text)
        else:
            corrected_text.append(token.text)
    return ' '.join(corrected_text)

# Function to ensure subject-verb agreement
def ensure_subject_verb_agreement(text):
    doc = nlp(text)
    corrected_text = []
    for token in doc:
        if token.dep_ == "nsubj" and token.head.pos_ == "VERB":
            if token.tag_ == "NN" and token.head.tag_ != "VBZ":
                corrected_text.append(token.head.lemma_ + "s")
            elif token.tag_ == "NNS" and token.head.tag_ == "VBZ":
                corrected_text.append(token.head.lemma_)
        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 if corrected_word is not None else word)
    return ' '.join(corrected_words)

# Main processing function for paraphrasing and grammar correction
def paraphrase_and_correct(text):
    cleaned_text = remove_redundant_words(text)
    cleaned_text = fix_punctuation_spacing(cleaned_text)
    cleaned_text = fix_possessives(cleaned_text)
    cleaned_text = capitalize_sentences_and_nouns(cleaned_text)
    cleaned_text = force_first_letter_capital(cleaned_text)
    cleaned_text = correct_tense_errors(cleaned_text)
    cleaned_text = correct_article_errors(cleaned_text)
    cleaned_text = ensure_subject_verb_agreement(cleaned_text)
    cleaned_text = correct_spelling(cleaned_text)
    plag_removed = plagiarism_remover(cleaned_text)
    return plag_removed

# Create the Gradio interface
with gr.Blocks() as demo:
    gr.Markdown("# AI Text Processor")
    
    with gr.Tab("AI Detection"):
        t1 = gr.Textbox(lines=5, label='Input Text')
        btn1 = gr.Button("Detect AI")
        out1 = gr.Textbox(label='Prediction', interactive=False)
        out2 = gr.Textbox(label='Confidence', interactive=False)
        btn1.click(fn=predict_en, inputs=t1, outputs=[out1, out2])

    with gr.Tab("Paraphrasing and Grammar Correction"):
        t2 = gr.Textbox(lines=5, label='Input Text')
        btn2 = gr.Button("Process Text")
        out3 = gr.Textbox(label='Processed Text', interactive=False)
        btn2.click(fn=paraphrase_and_correct, inputs=t2, outputs=out3)

demo.launch()