Update app.py

app.py

@@ -1,1112 +1,231 @@
 import os
 import gradio as gr
-import random
-import re
+from transformers import pipeline
+import spacy
+import subprocess
 import nltk
-import numpy as np
-import torch
-from collections import defaultdict, Counter
+from nltk.corpus import wordnet
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+from spellchecker import SpellChecker
+import re
 import string
-import math
-from typing import List, Dict, Tuple, Optional
-
-# Core NLP imports with fallback handling
-try:
-    import spacy
-    SPACY_AVAILABLE = True
-except ImportError:
-    SPACY_AVAILABLE = False
-
-try:
-    from transformers import (
-        AutoTokenizer, AutoModelForSequenceClassification,
-        T5Tokenizer, T5ForConditionalGeneration,
-        pipeline, BertTokenizer, BertModel
-    )
-    TRANSFORMERS_AVAILABLE = True
-except ImportError:
-    TRANSFORMERS_AVAILABLE = False
-
-try:
-    from sentence_transformers import SentenceTransformer
-    SENTENCE_TRANSFORMERS_AVAILABLE = True
-except ImportError:
-    SENTENCE_TRANSFORMERS_AVAILABLE = False
-
-try:
-    from textblob import TextBlob
-    TEXTBLOB_AVAILABLE = True
-except ImportError:
-    TEXTBLOB_AVAILABLE = False
-
-try:
-    from sklearn.metrics.pairwise import cosine_similarity
-    SKLEARN_AVAILABLE = True
-except ImportError:
-    SKLEARN_AVAILABLE = False
-
-from textstat import flesch_reading_ease, flesch_kincaid_grade
-from nltk.tokenize import sent_tokenize, word_tokenize
-from nltk.corpus import wordnet, stopwords
-from nltk.tag import pos_tag
-
-# Setup environment
-os.environ['NLTK_DATA'] = '/tmp/nltk_data'
-os.environ['TOKENIZERS_PARALLELISM'] = 'false'
-
-def download_dependencies():
-    """Download all required dependencies with error handling"""
-    try:
-        # NLTK data
-        os.makedirs('/tmp/nltk_data', exist_ok=True)
-        nltk.data.path.append('/tmp/nltk_data')
-        
-        required_nltk = ['punkt', 'punkt_tab', 'averaged_perceptron_tagger', 
-                        'stopwords', 'wordnet', 'omw-1.4', 'vader_lexicon']
-        
-        for data in required_nltk:
-            try:
-                nltk.download(data, download_dir='/tmp/nltk_data', quiet=True)
-            except Exception as e:
-                print(f"Failed to download {data}: {e}")
-        
-        print("✅ NLTK dependencies loaded")
-        
-    except Exception as e:
-        print(f"❌ Dependency setup error: {e}")
-
-download_dependencies()
-
-class AdvancedAIHumanizer:
-    def __init__(self):
-        self.setup_models()
-        self.setup_humanization_patterns()
-        self.load_linguistic_resources()
-        self.setup_fallback_embeddings()
-        
-    def setup_models(self):
-        """Initialize advanced NLP models with fallback handling"""
-        try:
-            print("🔄 Loading advanced models...")
-            
-            # Sentence transformer for semantic similarity
-            if SENTENCE_TRANSFORMERS_AVAILABLE:
-                try:
-                    self.sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
-                    print("✅ Sentence transformer loaded")
-                except:
-                    self.sentence_model = None
-                    print("⚠️ Sentence transformer not available")
-            else:
-                self.sentence_model = None
-                print("⚠️ sentence-transformers not installed")
-            
-            # Paraphrasing model
-            if TRANSFORMERS_AVAILABLE:
-                try:
-                    self.paraphrase_tokenizer = T5Tokenizer.from_pretrained('t5-small')
-                    self.paraphrase_model = T5ForConditionalGeneration.from_pretrained('t5-small')
-                    print("✅ T5 paraphrasing model loaded")
-                except:
-                    self.paraphrase_tokenizer = None
-                    self.paraphrase_model = None
-                    print("⚠️ T5 paraphrasing model not available")
-            else:
-                self.paraphrase_tokenizer = None
-                self.paraphrase_model = None
-                print("⚠️ transformers not installed")
-            
-            # SpaCy model
-            if SPACY_AVAILABLE:
-                try:
-                    self.nlp = spacy.load("en_core_web_sm")
-                    print("✅ SpaCy model loaded")
-                except:
-                    try:
-                        os.system("python -m spacy download en_core_web_sm")
-                        self.nlp = spacy.load("en_core_web_sm")
-                        print("✅ SpaCy model downloaded and loaded")
-                    except:
-                        self.nlp = None
-                        print("⚠️ SpaCy model not available")
-            else:
-                self.nlp = None
-                print("⚠️ spaCy not installed")
-                
-        except Exception as e:
-            print(f"❌ Model setup error: {e}")
-
-    def setup_fallback_embeddings(self):
-        """Setup fallback word similarity using simple patterns"""
-        # Common word groups for similarity
-        self.word_groups = {
-            'analyze': ['examine', 'study', 'investigate', 'explore', 'review', 'assess'],
-            'important': ['crucial', 'vital', 'significant', 'essential', 'key', 'critical'],
-            'shows': ['demonstrates', 'reveals', 'indicates', 'displays', 'exhibits'],
-            'understand': ['comprehend', 'grasp', 'realize', 'recognize', 'appreciate'],
-            'develop': ['create', 'build', 'establish', 'form', 'generate', 'produce'],
-            'improve': ['enhance', 'better', 'upgrade', 'refine', 'advance', 'boost'],
-            'consider': ['think about', 'examine', 'evaluate', 'contemplate', 'ponder'],
-            'different': ['various', 'diverse', 'distinct', 'separate', 'alternative'],
-            'effective': ['successful', 'efficient', 'productive', 'powerful', 'useful'],
-            'significant': ['important', 'substantial', 'considerable', 'notable', 'major'],
-            'implement': ['apply', 'execute', 'carry out', 'put into practice', 'deploy'],
-            'utilize': ['use', 'employ', 'apply', 'harness', 'leverage', 'exploit'],
-            'comprehensive': ['complete', 'thorough', 'extensive', 'detailed', 'full'],
-            'fundamental': ['basic', 'essential', 'core', 'primary', 'key', 'central'],
-            'substantial': ['significant', 'considerable', 'large', 'major', 'extensive']
-        }
-        
-        # Reverse mapping for quick lookup
-        self.synonym_map = {}
-        for base_word, synonyms in self.word_groups.items():
-            for synonym in synonyms:
-                if synonym not in self.synonym_map:
-                    self.synonym_map[synonym] = []
-                self.synonym_map[synonym].extend([base_word] + [s for s in synonyms if s != synonym])
-
-    def setup_humanization_patterns(self):
-        """Setup comprehensive humanization patterns"""
-        
-        # Expanded AI-flagged terms with more variations
-        self.ai_indicators = {
-            # Academic/Formal terms
-            r'\bdelve into\b': ["explore", "examine", "investigate", "look into", "study", "dig into", "analyze"],
-            r'\bembark upon?\b': ["begin", "start", "initiate", "launch", "set out", "commence", "kick off"],
-            r'\ba testament to\b': ["proof of", "evidence of", "shows", "demonstrates", "reflects", "indicates"],
-            r'\blandscape of\b': ["world of", "field of", "area of", "context of", "environment of", "space of"],
-            r'\bnavigating\b': ["handling", "managing", "dealing with", "working through", "tackling", "addressing"],
-            r'\bmeticulous\b': ["careful", "thorough", "detailed", "precise", "systematic", "methodical"],
-            r'\bintricate\b': ["complex", "detailed", "sophisticated", "elaborate", "complicated", "involved"],
-            r'\bmyriad\b': ["many", "numerous", "countless", "various", "multiple", "lots of"],
-            r'\bplethora\b': ["abundance", "wealth", "variety", "range", "loads", "tons"],
-            r'\bparadigm\b': ["model", "framework", "approach", "system", "way", "method"],
-            r'\bsynergy\b': ["teamwork", "cooperation", "collaboration", "working together", "unity"],
-            r'\bleverage\b': ["use", "utilize", "employ", "apply", "tap into", "make use of"],
-            r'\bfacilitate\b': ["help", "assist", "enable", "support", "aid", "make easier"],
-            r'\boptimize\b': ["improve", "enhance", "refine", "perfect", "boost", "maximize"],
-            r'\bstreamline\b': ["simplify", "improve", "refine", "smooth out", "make efficient"],
-            r'\brobust\b': ["strong", "reliable", "solid", "sturdy", "effective", "powerful"],
-            r'\bseamless\b': ["smooth", "fluid", "effortless", "easy", "integrated", "unified"],
-            r'\binnovative\b': ["creative", "original", "new", "fresh", "groundbreaking", "inventive"],
-            r'\bcutting-edge\b': ["advanced", "modern", "latest", "new", "state-of-the-art", "leading"],
-            r'\bstate-of-the-art\b': ["advanced", "modern", "latest", "top-notch", "cutting-edge"],
-            
-            # Transition phrases - more natural alternatives
-            r'\bfurthermore\b': ["also", "plus", "what's more", "on top of that", "besides", "additionally"],
-            r'\bmoreover\b': ["also", "plus", "what's more", "on top of that", "besides", "furthermore"],
-            r'\bhowever\b': ["but", "yet", "though", "still", "although", "that said"],
-            r'\bnevertheless\b': ["still", "yet", "even so", "but", "however", "all the same"],
-            r'\btherefore\b': ["so", "thus", "that's why", "as a result", "because of this", "for this reason"],
-            r'\bconsequently\b': ["so", "therefore", "as a result", "because of this", "thus", "that's why"],
-            r'\bin conclusion\b': ["finally", "to wrap up", "in the end", "ultimately", "lastly", "to finish"],
-            r'\bto summarize\b': ["in short", "briefly", "to sum up", "basically", "in essence", "overall"],
-            r'\bin summary\b': ["briefly", "in short", "basically", "to sum up", "overall", "in essence"],
-            
-            # Academic connectors - more casual
-            r'\bin order to\b': ["to", "so I can", "so we can", "with the goal of", "aiming to"],
-            r'\bdue to the fact that\b': ["because", "since", "as", "given that", "seeing that"],
-            r'\bfor the purpose of\b': ["to", "in order to", "for", "aiming to", "with the goal of"],
-            r'\bwith regard to\b': ["about", "concerning", "regarding", "when it comes to", "as for"],
-            r'\bin terms of\b': ["regarding", "when it comes to", "as for", "concerning", "about"],
-            r'\bby means of\b': ["through", "using", "via", "by way of", "with"],
-            r'\bas a result of\b': ["because of", "due to", "from", "owing to", "thanks to"],
-            r'\bin the event that\b': ["if", "should", "in case", "when", "if it happens that"],
-            r'\bprior to\b': ["before", "ahead of", "earlier than", "in advance of"],
-            r'\bsubsequent to\b': ["after", "following", "later than", "once"],
-            
-            # Additional formal patterns
-            r'\bcomprehensive\b': ["complete", "thorough", "detailed", "full", "extensive", "in-depth"],
-            r'\bfundamental\b': ["basic", "essential", "core", "key", "primary", "main"],
-            r'\bsubstantial\b': ["significant", "considerable", "large", "major", "big", "huge"],
-            r'\bsignificant\b': ["important", "major", "considerable", "substantial", "notable", "big"],
-            r'\bimplement\b': ["put in place", "carry out", "apply", "execute", "use", "deploy"],
-            r'\butilize\b': ["use", "employ", "apply", "make use of", "tap into", "leverage"],
-            r'\bdemonstrate\b': ["show", "prove", "illustrate", "reveal", "display", "exhibit"],
-            r'\bestablish\b': ["set up", "create", "build", "form", "start", "found"],
-            r'\bmaintain\b': ["keep", "preserve", "sustain", "continue", "uphold", "retain"],
-            r'\bobtain\b': ["get", "acquire", "gain", "secure", "achieve", "attain"],
-        }
-        
-        # More natural sentence starters
-        self.human_starters = [
-            "Actually,", "Honestly,", "Basically,", "Really,", "Generally,", "Usually,",
-            "Often,", "Sometimes,", "Clearly,", "Obviously,", "Naturally,", "Certainly,",
-            "Definitely,", "Interestingly,", "Surprisingly,", "Notably,", "Importantly,",
-            "What's more,", "Plus,", "Also,", "Besides,", "On top of that,", "In fact,",
-            "Indeed,", "Of course,", "No doubt,", "Without question,", "Frankly,",
-            "To be honest,", "Truth is,", "The thing is,", "Here's the deal,", "Look,"
-        ]
-        
-        # Professional but natural contractions
-        self.contractions = {
-            r'\bit is\b': "it's", r'\bthat is\b': "that's", r'\bthere is\b': "there's",
-            r'\bwho is\b': "who's", r'\bwhat is\b': "what's", r'\bwhere is\b': "where's",
-            r'\bthey are\b': "they're", r'\bwe are\b': "we're", r'\byou are\b': "you're",
-            r'\bI am\b': "I'm", r'\bhe is\b': "he's", r'\bshe is\b': "she's",
-            r'\bcannot\b': "can't", r'\bdo not\b': "don't", r'\bdoes not\b': "doesn't",
-            r'\bwill not\b': "won't", r'\bwould not\b': "wouldn't", r'\bshould not\b': "shouldn't",
-            r'\bcould not\b': "couldn't", r'\bhave not\b': "haven't", r'\bhas not\b': "hasn't",
-            r'\bhad not\b': "hadn't", r'\bis not\b': "isn't", r'\bare not\b': "aren't",
-            r'\bwas not\b': "wasn't", r'\bwere not\b': "weren't", r'\blet us\b': "let's",
-            r'\bI will\b': "I'll", r'\byou will\b': "you'll", r'\bwe will\b': "we'll",
-            r'\bthey will\b': "they'll", r'\bI would\b': "I'd", r'\byou would\b': "you'd"
-        }
-
-    def load_linguistic_resources(self):
-        """Load additional linguistic resources"""
-        try:
-            # Stop words
-            self.stop_words = set(stopwords.words('english'))
-            
-            # Common filler words and phrases for natural flow
-            self.fillers = [
-                "you know", "I mean", "sort of", "kind of", "basically", "actually",
-                "really", "quite", "pretty much", "more or less", "essentially"
-            ]
-            
-            # Natural transition phrases
-            self.natural_transitions = [
-                "And here's the thing:", "But here's what's interesting:", "Now, here's where it gets good:",
-                "So, what does this mean?", "Here's why this matters:", "Think about it this way:",
-                "Let me put it this way:", "Here's the bottom line:", "The reality is:",
-                "What we're seeing is:", "The truth is:", "At the end of the day:"
-            ]
-            
-            print("✅ Linguistic resources loaded")
-            
-        except Exception as e:
-            print(f"❌ Linguistic resource error: {e}")
+import random
 
-    def calculate_perplexity(self, text: str) -> float:
-        """Calculate text perplexity to measure predictability"""
-        try:
-            words = word_tokenize(text.lower())
-            if len(words) < 2:
-                return 50.0
-                
-            word_freq = Counter(words)
-            total_words = len(words)
-            
-            # Calculate entropy
-            entropy = 0
-            for word in words:
-                prob = word_freq[word] / total_words
-                if prob > 0:
-                    entropy -= prob * math.log2(prob)
-            
-            perplexity = 2 ** entropy
-            
-            # Normalize to human-like range (40-80)
-            if perplexity < 20:
-                perplexity += random.uniform(20, 30)
-            elif perplexity > 100:
-                perplexity = random.uniform(60, 80)
-                
-            return perplexity
-            
-        except:
-            return random.uniform(45, 75)  # Human-like default
+# Download necessary NLTK data
+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')
 
-    def calculate_burstiness(self, text: str) -> float:
-        """Calculate burstiness (variation in sentence length)"""
-        try:
-            sentences = sent_tokenize(text)
-            if len(sentences) < 2:
-                return 1.2
-                
-            lengths = [len(word_tokenize(sent)) for sent in sentences]
-            
-            if len(lengths) < 2:
-                return 1.2
-                
-            mean_length = np.mean(lengths)
-            variance = np.var(lengths)
-            
-            if mean_length == 0:
-                return 1.2
-                
-            burstiness = variance / mean_length
-            
-            # Ensure human-like burstiness (>0.5)
-            if burstiness < 0.5:
-                burstiness = random.uniform(0.7, 1.5)
-                
-            return burstiness
-            
-        except:
-            return random.uniform(0.8, 1.4)  # Human-like default
+# Initialize stopwords
+stop_words = set(stopwords.words("english"))
 
-    def get_semantic_similarity(self, text1: str, text2: str) -> float:
-        """Calculate semantic similarity between texts"""
-        try:
-            if self.sentence_model and SKLEARN_AVAILABLE:
-                embeddings = self.sentence_model.encode([text1, text2])
-                similarity = cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
-                return float(similarity)
-            else:
-                # Fallback: simple word overlap similarity
-                words1 = set(word_tokenize(text1.lower()))
-                words2 = set(word_tokenize(text2.lower()))
-                
-                if not words1 or not words2:
-                    return 0.8
-                
-                intersection = len(words1.intersection(words2))
-                union = len(words1.union(words2))
-                
-                if union == 0:
-                    return 0.8
-                    
-                jaccard_sim = intersection / union
-                return max(0.7, jaccard_sim)  # Minimum baseline
-                
-        except Exception as e:
-            print(f"Similarity calculation error: {e}")
-            return 0.8
+# Words 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'}
 
-    def advanced_paraphrase(self, text: str, max_length: int = 256) -> str:
-        """Advanced paraphrasing using T5 or fallback methods"""
-        try:
-            if self.paraphrase_model and self.paraphrase_tokenizer:
-                # Use T5 for paraphrasing
-                input_text = f"paraphrase: {text}"
-                inputs = self.paraphrase_tokenizer.encode(
-                    input_text, 
-                    return_tensors='pt', 
-                    max_length=max_length, 
-                    truncation=True
-                )
-                
-                with torch.no_grad():
-                    outputs = self.paraphrase_model.generate(
-                        inputs, 
-                        max_length=max_length,
-                        num_return_sequences=1,
-                        temperature=0.8,
-                        do_sample=True,
-                        top_p=0.9,
-                        repetition_penalty=1.1
-                    )
-                
-                paraphrased = self.paraphrase_tokenizer.decode(outputs[0], skip_special_tokens=True)
-                
-                # Check semantic similarity
-                similarity = self.get_semantic_similarity(text, paraphrased)
-                if similarity > 0.7:
-                    return paraphrased
-                    
-            # Fallback: manual paraphrasing
-            return self.manual_paraphrase(text)
-            
-        except Exception as e:
-            print(f"Paraphrase error: {e}")
-            return self.manual_paraphrase(text)
+# Initialize the English text classification pipeline for AI detection
+pipeline_en = pipeline(task="text-classification", model="Hello-SimpleAI/chatgpt-detector-roberta")
 
-    def manual_paraphrase(self, text: str) -> str:
-        """Manual paraphrasing as fallback"""
-        # Simple restructuring patterns
-        patterns = [
-            # Active to passive hints
-            (r'(\w+) shows that (.+)', r'It is shown by \1 that \2'),
-            (r'(\w+) demonstrates (.+)', r'This demonstrates \2 through \1'),
-            (r'We can see that (.+)', r'It becomes clear that \1'),
-            (r'This indicates (.+)', r'What this shows is \1'),
-            (r'Research shows (.+)', r'Studies reveal \1'),
-            (r'It is important to note (.+)', r'Worth noting is \1'),
-        ]
-        
-        result = text
-        for pattern, replacement in patterns:
-            if re.search(pattern, result, re.IGNORECASE):
-                result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
-                break
-                
-        return result
+# Initialize the spell checker
+spell = SpellChecker()
 
-    def get_contextual_synonym(self, word: str, context: str = "") -> str:
-        """Get contextually appropriate synonym with fallback"""
-        try:
-            # First try the predefined word groups
-            word_lower = word.lower()
-            
-            if word_lower in self.word_groups:
-                synonyms = self.word_groups[word_lower]
-                return random.choice(synonyms)
-            
-            if word_lower in self.synonym_map:
-                synonyms = self.synonym_map[word_lower]
-                return random.choice(synonyms)
-            
-            # Fallback to WordNet
-            synsets = wordnet.synsets(word.lower())
-            if synsets:
-                synonyms = []
-                for synset in synsets[:2]:
-                    for lemma in synset.lemmas():
-                        synonym = lemma.name().replace('_', ' ')
-                        if synonym != word.lower() and len(synonym) > 2:
-                            synonyms.append(synonym)
-                
-                if synonyms:
-                    # Prefer synonyms with similar length
-                    suitable = [s for s in synonyms if abs(len(s) - len(word)) <= 3]
-                    if suitable:
-                        return random.choice(suitable[:3])
-                    return random.choice(synonyms[:3])
-            
-            return word
-            
-        except:
+# 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")
+
+def plagiarism_removal(text):
+    def plagiarism_remover(word):
+        if word.lower() in stop_words or word.lower() in exclude_words or word in string.punctuation:
             return word
-
-    def advanced_sentence_restructure(self, sentence: str) -> str:
-        """Advanced sentence restructuring"""
-        try:
-            # Multiple restructuring strategies
-            strategies = [
-                self.move_adverb_clause,
-                self.split_compound_sentence,
-                self.vary_voice_advanced,
-                self.add_casual_connector,
-                self.restructure_with_emphasis
-            ]
-            
-            strategy = random.choice(strategies)
-            result = strategy(sentence)
-            
-            # Ensure we didn't break the sentence
-            if len(result.split()) < 3 or not result.strip():
-                return sentence
-                
-            return result
-            
-        except:
-            return sentence
-
-    def move_adverb_clause(self, sentence: str) -> str:
-        """Move adverbial clauses for variation"""
-        patterns = [
-            (r'^(.*?),\s*(because|since|when|if|although|while|as)\s+(.*?)([.!?])$', 
-             r'\2 \3, \1\4'),
-            (r'^(.*?)\s+(because|since|when|if|although|while|as)\s+(.*?)([.!?])$', 
-             r'\2 \3, \1\4'),
-            (r'^(Although|While|Since|Because|When|If)\s+(.*?),\s*(.*?)([.!?])$',
-             r'\3, \1 \2\4')
-        ]
-        
-        for pattern, replacement in patterns:
-            if re.search(pattern, sentence, re.IGNORECASE):
-                result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
-                if result != sentence and len(result.split()) >= 3:
-                    return result.strip()
-        
-        return sentence
-
-    def split_compound_sentence(self, sentence: str) -> str:
-        """Split overly long compound sentences"""
-        conjunctions = [', and ', ', but ', ', so ', ', yet ', ', or ', '; however,', '; moreover,']
         
-        for conj in conjunctions:
-            if conj in sentence and len(sentence.split()) > 15:
-                parts = sentence.split(conj, 1)
-                if len(parts) == 2:
-                    first = parts[0].strip()
-                    second = parts[1].strip()
-                    
-                    # Ensure both parts are substantial
-                    if len(first.split()) > 3 and len(second.split()) > 3:
-                        # Add period to first part if needed
-                        if not first.endswith(('.', '!', '?')):
-                            first += '.'
-                        
-                        # Capitalize second part
-                        if second and second[0].islower():
-                            second = second[0].upper() + second[1:]
-                        
-                        # Add natural connector
-                        connectors = ["Also,", "Plus,", "Additionally,", "What's more,", "On top of that,"]
-                        connector = random.choice(connectors)
-                        
-                        return f"{first} {connector} {second.lower()}"
-        
-        return sentence
-
-    def vary_voice_advanced(self, sentence: str) -> str:
-        """Advanced voice variation"""
-        # Passive to active patterns
-        passive_patterns = [
-            (r'(\w+)\s+(?:is|are|was|were)\s+(\w+ed|shown|seen|made|used|done|taken|given|found)\s+by\s+(.+)',
-             r'\3 \2 \1'),
-            (r'(\w+)\s+(?:has|have)\s+been\s+(\w+ed|shown|seen|made|used|done|taken|given|found)\s+by\s+(.+)',
-             r'\3 \2 \1'),
-            (r'It\s+(?:is|was)\s+(\w+ed|shown|found|discovered)\s+that\s+(.+)',
-             r'Research \1 that \2'),
-            (r'(\w+)\s+(?:is|are)\s+considered\s+(.+)',
-             r'Experts consider \1 \2')
-        ]
-        
-        for pattern, replacement in passive_patterns:
-            if re.search(pattern, sentence, re.IGNORECASE):
-                result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
-                if result != sentence:
-                    return result
-        
-        return sentence
+        # Find synonyms
+        synonyms = set()
+        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())
 
-    def add_casual_connector(self, sentence: str) -> str:
-        """Add casual connectors for natural flow"""
-        if len(sentence.split()) > 8:
-            # Insert casual phrases
-            casual_insertions = [
-                ", you know,", ", I mean,", ", basically,", ", actually,",
-                ", really,", ", essentially,", ", fundamentally,"
-            ]
-            
-            # Find a good insertion point (after a comma)
-            if ',' in sentence:
-                parts = sentence.split(',', 1)
-                if len(parts) == 2 and random.random() < 0.3:
-                    insertion = random.choice(casual_insertions)
-                    return f"{parts[0]}{insertion}{parts[1]}"
-        
-        return sentence
+        pos_tag_word = nltk.pos_tag([word])[0]
 
-    def restructure_with_emphasis(self, sentence: str) -> str:
-        """Restructure with natural emphasis"""
-        emphasis_patterns = [
-            (r'^The fact that (.+) is (.+)', r'What\'s \2 is that \1'),
-            (r'^It is (.+) that (.+)', r'What\'s \1 is that \2'),
-            (r'^(.+) is very important', r'\1 really matters'),
-            (r'^This shows that (.+)', r'This proves \1'),
-            (r'^Research indicates (.+)', r'Studies show \1'),
-            (r'^It can be seen that (.+)', r'We can see that \1')
-        ]
-        
-        for pattern, replacement in emphasis_patterns:
-            if re.search(pattern, sentence, re.IGNORECASE):
-                result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
-                if result != sentence:
-                    return result
-        
-        return sentence
-
-    def add_human_touches(self, text: str, intensity: int = 2) -> str:
-        """Add human-like writing patterns"""
-        sentences = sent_tokenize(text)
-        humanized = []
-        
-        touch_probability = {1: 0.15, 2: 0.25, 3: 0.4}
-        prob = touch_probability.get(intensity, 0.25)
-        
-        for i, sentence in enumerate(sentences):
-            current = sentence
-            
-            # Add natural starters occasionally
-            if i > 0 and random.random() < prob and len(current.split()) > 6:
-                starter = random.choice(self.human_starters)
-                current = f"{starter} {current[0].lower() + current[1:]}"
-            
-            # Add natural transitions between sentences
-            if i > 0 and random.random() < prob * 0.3:
-                transition = random.choice(self.natural_transitions)
-                current = f"{transition} {current[0].lower() + current[1:]}"
-            
-            # Add casual fillers occasionally
-            if random.random() < prob * 0.2 and len(current.split()) > 10:
-                filler = random.choice(self.fillers)
-                words = current.split()
-                # Insert filler in middle
-                mid_point = len(words) // 2
-                words.insert(mid_point, f", {filler},")
-                current = " ".join(words)
-            
-            # Vary sentence endings for naturalness
-            if random.random() < prob * 0.2:
-                current = self.vary_sentence_ending(current)
-            
-            humanized.append(current)
-        
-        return " ".join(humanized)
-
-    def vary_sentence_ending(self, sentence: str) -> str:
-        """Add variety to sentence endings"""
-        if sentence.endswith('.'):
-            variations = [
-                (r'(\w+) is important\.', r'\1 matters.'),
-                (r'(\w+) is significant\.', r'\1 is really important.'),
-                (r'This shows (.+)\.', r'This proves \1.'),
-                (r'(\w+) demonstrates (.+)\.', r'\1 clearly shows \2.'),
-                (r'(\w+) indicates (.+)\.', r'\1 suggests \2.'),
-                (r'It is clear that (.+)\.', r'Obviously, \1.'),
-                (r'(\w+) reveals (.+)\.', r'\1 shows us \2.'),
-            ]
-            
-            for pattern, replacement in variations:
-                if re.search(pattern, sentence, re.IGNORECASE):
-                    result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
-                    if result != sentence:
-                        return result
-        
-        return sentence
-
-    def apply_advanced_contractions(self, text: str, intensity: int = 2) -> str:
-        """Apply natural contractions"""
-        contraction_probability = {1: 0.4, 2: 0.6, 3: 0.8}
-        prob = contraction_probability.get(intensity, 0.6)
-        
-        for pattern, contraction in self.contractions.items():
-            if re.search(pattern, text, re.IGNORECASE) and random.random() < prob:
-                text = re.sub(pattern, contraction, text, flags=re.IGNORECASE)
+        if pos_tag_word[1] in exclude_tags:
+            return word
         
-        return text
+        filtered_synonyms = [syn for syn in synonyms if nltk.pos_tag([syn])[0][1] == pos_tag_word[1]]
 
-    def enhance_vocabulary_diversity(self, text: str, intensity: int = 2) -> str:
-        """Enhanced vocabulary diversification"""
-        words = word_tokenize(text)
-        enhanced = []
-        word_usage = defaultdict(int)
-        
-        synonym_probability = {1: 0.2, 2: 0.35, 3: 0.5}
-        prob = synonym_probability.get(intensity, 0.35)
-        
-        # Track word frequency
-        for word in words:
-            if word.isalpha() and len(word) > 3:
-                word_usage[word.lower()] += 1
-        
-        for i, word in enumerate(words):
-            if (word.isalpha() and len(word) > 3 and 
-                word.lower() not in self.stop_words and
-                word_usage[word.lower()] > 1 and 
-                random.random() < prob):
-                
-                # Get context
-                context_start = max(0, i - 5)
-                context_end = min(len(words), i + 5)
-                context = " ".join(words[context_start:context_end])
-                
-                synonym = self.get_contextual_synonym(word, context)
-                enhanced.append(synonym)
-                word_usage[word.lower()] -= 1  # Reduce frequency count
-            else:
-                enhanced.append(word)
-        
-        return " ".join(enhanced)
+        if not filtered_synonyms:
+            return word
 
-    def multiple_pass_humanization(self, text: str, intensity: int = 2) -> str:
-        """Apply multiple humanization passes"""
-        current_text = text
-        
-        passes = {1: 3, 2: 4, 3: 5}  # Increased passes for better results
-        num_passes = passes.get(intensity, 4)
-        
-        for pass_num in range(num_passes):
-            print(f"🔄 Pass {pass_num + 1}/{num_passes}")
-            
-            if pass_num == 0:
-                # Pass 1: AI pattern replacement
-                current_text = self.replace_ai_patterns(current_text, intensity)
-                
-            elif pass_num == 1:
-                # Pass 2: Sentence restructuring
-                current_text = self.restructure_sentences(current_text, intensity)
-                
-            elif pass_num == 2:
-                # Pass 3: Vocabulary enhancement
-                current_text = self.enhance_vocabulary_diversity(current_text, intensity)
-                
-            elif pass_num == 3:
-                # Pass 4: Contractions and human touches
-                current_text = self.apply_advanced_contractions(current_text, intensity)
-                current_text = self.add_human_touches(current_text, intensity)
-                
-            elif pass_num == 4:
-                # Pass 5: Final paraphrasing and polish
-                sentences = sent_tokenize(current_text)
-                final_sentences = []
-                for sent in sentences:
-                    if len(sent.split()) > 10 and random.random() < 0.3:
-                        paraphrased = self.advanced_paraphrase(sent)
-                        final_sentences.append(paraphrased)
-                    else:
-                        final_sentences.append(sent)
-                current_text = " ".join(final_sentences)
-            
-            # Check semantic preservation
-            similarity = self.get_semantic_similarity(text, current_text)
-            print(f"   Semantic similarity: {similarity:.2f}")
-            
-            if similarity < 0.7:
-                print(f"⚠️ Semantic drift detected, using previous version")
-                break
-        
-        return current_text
+        synonym_choice = random.choice(filtered_synonyms)
 
-    def replace_ai_patterns(self, text: str, intensity: int = 2) -> str:
-        """Replace AI-flagged patterns aggressively"""
-        result = text
-        replacement_probability = {1: 0.7, 2: 0.85, 3: 0.95}
-        prob = replacement_probability.get(intensity, 0.85)
-        
-        for pattern, replacements in self.ai_indicators.items():
-            matches = list(re.finditer(pattern, result, re.IGNORECASE))
-            for match in reversed(matches):  # Replace from end to preserve positions
-                if random.random() < prob:
-                    replacement = random.choice(replacements)
-                    result = result[:match.start()] + replacement + result[match.end():]
-        
-        return result
+        if word.istitle():
+            return synonym_choice.title()
+        return synonym_choice
 
-    def restructure_sentences(self, text: str, intensity: int = 2) -> str:
-        """Restructure sentences for maximum variation"""
-        sentences = sent_tokenize(text)
-        restructured = []
-        
-        restructure_probability = {1: 0.3, 2: 0.5, 3: 0.7}
-        prob = restructure_probability.get(intensity, 0.5)
-        
-        for sentence in sentences:
-            if len(sentence.split()) > 8 and random.random() < prob:
-                restructured_sent = self.advanced_sentence_restructure(sentence)
-                restructured.append(restructured_sent)
+    para_split = word_tokenize(text)
+    final_text = [plagiarism_remover(word) for word in para_split]
+    
+    corrected_text = []
+    for i in range(len(final_text)):
+        if final_text[i] in string.punctuation and i > 0:
+            corrected_text[-1] += final_text[i]  
+        else:
+            corrected_text.append(final_text[i])
+
+    return " ".join(corrected_text)
+
+def predict_en(text):
+    res = pipeline_en(text)[0]
+    return res['label'], res['score']
+
+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)
+
+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(' :', ':')
+
+def fix_possessives(text):
+    text = re.sub(r'(\w)\s\'\s?s', r"\1's", text)
+    return text
+
+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:
-                restructured.append(sentence)
-        
-        return " ".join(restructured)
-
-    def final_quality_check(self, original: str, processed: str) -> Tuple[str, Dict]:
-        """Final quality and coherence check"""
-        # Calculate metrics
-        metrics = {
-            'semantic_similarity': self.get_semantic_similarity(original, processed),
-            'perplexity': self.calculate_perplexity(processed),
-            'burstiness': self.calculate_burstiness(processed),
-            'readability': flesch_reading_ease(processed)
-        }
-        
-        # Ensure human-like metrics
-        if metrics['perplexity'] < 40:
-            metrics['perplexity'] = random.uniform(45, 75)
-        if metrics['burstiness'] < 0.5:
-            metrics['burstiness'] = random.uniform(0.7, 1.4)
-        
-        # Final cleanup
-        processed = re.sub(r'\s+', ' ', processed)
-        processed = re.sub(r'\s+([,.!?;:])', r'\1', processed)
-        processed = re.sub(r'([,.!?;:])\s*([A-Z])', r'\1 \2', processed)
-        
-        # Ensure proper capitalization
-        sentences = sent_tokenize(processed)
-        corrected = []
-        for sentence in sentences:
-            if sentence and sentence[0].islower():
-                sentence = sentence[0].upper() + sentence[1:]
-            corrected.append(sentence)
-        
-        processed = " ".join(corrected)
-        processed = re.sub(r'\.+', '.', processed)
-        processed = processed.strip()
-        
-        return processed, metrics
-
-    def humanize_text(self, text: str, intensity: str = "standard") -> str:
-        """Main humanization method with advanced processing"""
-        if not text or not text.strip():
-            return "Please provide text to humanize."
-        
-        try:
-            # Map intensity
-            intensity_mapping = {"light": 1, "standard": 2, "heavy": 3}
-            intensity_level = intensity_mapping.get(intensity, 2)
-            
-            print(f"🚀 Starting advanced humanization (Level {intensity_level})")
-            
-            # Pre-processing
-            text = text.strip()
-            original_text = text
-            
-            # Multi-pass humanization
-            result = self.multiple_pass_humanization(text, intensity_level)
-            
-            # Final quality check
-            result, metrics = self.final_quality_check(original_text, result)
-            
-            print(f"✅ Humanization complete")
-            print(f"📊 Final metrics - Similarity: {metrics['semantic_similarity']:.2f}, Perplexity: {metrics['perplexity']:.1f}, Burstiness: {metrics['burstiness']:.1f}")
-            
-            return result
-            
-        except Exception as e:
-            print(f"❌ Humanization error: {e}")
-            return f"Error processing text: {str(e)}"
-
-    def get_detailed_analysis(self, text: str) -> str:
-        """Get detailed analysis of humanized text"""
-        try:
-            metrics = {
-                'readability': flesch_reading_ease(text),
-                'grade_level': flesch_kincaid_grade(text),
-                'perplexity': self.calculate_perplexity(text),
-                'burstiness': self.calculate_burstiness(text),
-                'sentence_count': len(sent_tokenize(text)),
-                'word_count': len(word_tokenize(text))
-            }
-            
-            # Readability assessment
-            score = metrics['readability']
-            level = ("Very Easy" if score >= 90 else "Easy" if score >= 80 else 
-                    "Fairly Easy" if score >= 70 else "Standard" if score >= 60 else 
-                    "Fairly Difficult" if score >= 50 else "Difficult" if score >= 30 else 
-                    "Very Difficult")
-            
-            # AI detection assessment
-            perplexity_good = metrics['perplexity'] >= 40
-            burstiness_good = metrics['burstiness'] >= 0.5
-            detection_bypass = "✅ EXCELLENT" if (perplexity_good and burstiness_good) else "⚠️ GOOD" if (perplexity_good or burstiness_good) else "❌ NEEDS WORK"
-            
-            analysis = f"""📊 Advanced Content Analysis:
-
-📖 Readability Metrics:
-• Flesch Score: {score:.1f} ({level})
-• Grade Level: {metrics['grade_level']:.1f}
-• Sentences: {metrics['sentence_count']}
-• Words: {metrics['word_count']}
-
-🤖 AI Detection Bypass:
-• Perplexity: {metrics['perplexity']:.1f} {'✅' if perplexity_good else '❌'} (Target: 40-80)
-• Burstiness: {metrics['burstiness']:.1f} {'✅' if burstiness_good else '❌'} (Target: >0.5)
-• Overall Status: {detection_bypass}
+                sentence.append(token.text)
+        corrected_text.append(' '.join(sentence))
 
-🎯 Detection Tool Results:
-• ZeroGPT: {'0% AI' if (perplexity_good and burstiness_good) else 'Low AI'}
-• Quillbot: {'Human' if (perplexity_good and burstiness_good) else 'Mostly Human'}
-• GPTZero: {'Undetectable' if (perplexity_good and burstiness_good) else 'Low Detection'}"""
-            
-            return analysis
-            
-        except Exception as e:
-            return f"Analysis error: {str(e)}"
+    return ' '.join(corrected_text)
 
-# Create enhanced interface
-def create_enhanced_interface():
-    """Create the enhanced Gradio interface"""
-    humanizer = AdvancedAIHumanizer()
+def force_first_letter_capital(text):
+    sentences = re.split(r'(?<=\w[.!?])\s+', text)
+    capitalized_sentences = []
     
-    def process_text_advanced(input_text, intensity):
-        if not input_text or len(input_text.strip()) < 10:
-            return "Please enter at least 10 characters of text to humanize.", "No analysis available."
-        
-        try:
-            result = humanizer.humanize_text(input_text, intensity)
-            analysis = humanizer.get_detailed_analysis(result)
-            return result, analysis
-        except Exception as e:
-            return f"Error: {str(e)}", "Processing failed."
-
-    # Enhanced CSS styling
-    enhanced_css = """
-    .gradio-container {
-        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        min-height: 100vh;
-    }
-    .main-header {
-        text-align: center;
-        color: white;
-        font-size: 2.8em;
-        font-weight: 800;
-        margin-bottom: 20px;
-        padding: 40px 20px;
-        text-shadow: 2px 2px 8px rgba(0,0,0,0.3);
-        background: rgba(255,255,255,0.1);
-        border-radius: 20px;
-        backdrop-filter: blur(10px);
-    }
-    .feature-card {
-        background: rgba(255, 255, 255, 0.95);
-        border-radius: 20px;
-        padding: 30px;
-        margin: 25px 0;
-        box-shadow: 0 10px 40px rgba(0,0,0,0.1);
-        backdrop-filter: blur(15px);
-        border: 1px solid rgba(255,255,255,0.2);
-    }
-    .enhancement-badge {
-        background: linear-gradient(45deg, #28a745, #20c997);
-        color: white;
-        padding: 10px 18px;
-        border-radius: 25px;
-        font-weight: 700;
-        margin: 8px;
-        display: inline-block;
-        box-shadow: 0 4px 15px rgba(40,167,69,0.3);
-        transition: transform 0.2s;
-    }
-    .enhancement-badge:hover {
-        transform: translateY(-2px);
-    }
-    .status-excellent { color: #28a745; font-weight: bold; }
-    .status-good { color: #ffc107; font-weight: bold; }
-    .status-needs-work { color: #dc3545; font-weight: bold; }
-    """
-
-    with gr.Blocks(
-        title="🧠 Advanced AI Humanizer Pro - 0% Detection", 
-        theme=gr.themes.Soft(),
-        css=enhanced_css
-    ) as interface:
-        
-        gr.HTML("""
-        <div class="main-header">
-            🧠 Advanced AI Humanizer Pro
-            <div style="font-size: 0.35em; margin-top: 15px; opacity: 0.9;">
-                🎯 Guaranteed 0% AI Detection • 🔒 Meaning Preservation • ⚡ Professional Quality
-            </div>
-        </div>
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                input_text = gr.Textbox(
-                    label="📄 AI Content Input", 
-                    lines=16, 
-                    placeholder="Paste your AI-generated content here...\n\n🚀 This advanced system uses multiple AI detection bypass techniques:\n• Multi-pass processing with 5 humanization layers\n• Perplexity optimization for unpredictability\n• Burstiness enhancement for natural variation\n• Semantic similarity preservation\n• Advanced paraphrasing with T5 models\n• Contextual synonym replacement\n\n💡 Minimum 50 words recommended for optimal results.",
-                    info="✨ Optimized for all AI detectors: ZeroGPT, Quillbot, GPTZero, Originality.ai",
-                    show_copy_button=True
-                )
-                
-                intensity = gr.Radio(
-                    choices=[
-                        ("🟢 Light (Conservative, 70% changes)", "light"),
-                        ("🟡 Standard (Balanced, 85% changes)", "standard"), 
-                        ("🔴 Heavy (Maximum, 95% changes)", "heavy")
-                    ], 
-                    value="standard", 
-                    label="🎛️ Humanization Intensity",
-                    info="⚡ Standard recommended for most content • Heavy for highly detectable AI text"
-                )
-                
-                btn = gr.Button(
-                    "🚀 Advanced Humanize (0% AI Detection)", 
-                    variant="primary", 
-                    size="lg"
-                )
-            
-            with gr.Column(scale=1):
-                output_text = gr.Textbox(
-                    label="✅ Humanized Content (0% AI Detection Guaranteed)", 
-                    lines=16, 
-                    show_copy_button=True,
-                    info="🎯 Ready for use - Bypasses all major AI detectors"
-                )
-                
-                analysis = gr.Textbox(
-                    label="📊 Advanced Detection Analysis", 
-                    lines=12,
-                    info="📈 Detailed metrics and bypass confirmation"
-                )
-        
-        gr.HTML("""
-        <div class="feature-card">
-            <h2 style="text-align: center; color: #2c3e50; margin-bottom: 25px;">🎯 Advanced AI Detection Bypass Technology</h2>
-            <div style="text-align: center; margin: 25px 0;">
-                <span class="enhancement-badge">🧠 T5 Transformer Models</span>
-                <span class="enhancement-badge">📊 Perplexity Optimization</span>
-                <span class="enhancement-badge">🔄 Multi-Pass Processing</span>
-                <span class="enhancement-badge">🎭 Semantic Preservation</span>
-                <span class="enhancement-badge">📝 Dependency Parsing</span>
-                <span class="enhancement-badge">💡 Contextual Synonyms</span>
-                <span class="enhancement-badge">🎯 Burstiness Enhancement</span>
-                <span class="enhancement-badge">🔍 Human Pattern Mimicking</span>
-            </div>
-        </div>
-        """)
-        
-        gr.HTML("""
-        <div class="feature-card">
-            <h3 style="color: #2c3e50; margin-bottom: 20px;">🛠️ Technical Specifications & Results:</h3>
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 25px; margin: 25px 0;">
-                <div style="background: linear-gradient(135deg, #e3f2fd, #bbdefb); padding: 20px; border-radius: 15px; border-left: 5px solid #2196f3;">
-                    <strong style="color: #1976d2;">🤖 AI Models & Techniques:</strong><br><br>
-                    • T5 Paraphrasing Engine<br>
-                    • BERT Contextual Analysis<br>
-                    • Sentence Transformers<br>
-                    • Advanced NLP Pipeline<br>
-                    • 5-Pass Processing System<br>
-                    • Semantic Similarity Checks
-                </div>
-                <div style="background: linear-gradient(135deg, #e8f5e8, #c8e6c9); padding: 20px; border-radius: 15px; border-left: 5px solid #4caf50;">
-                    <strong style="color: #388e3c;">📊 Quality Guarantees:</strong><br><br>
-                    • Semantic Similarity >85%<br>
-                    • Perplexity: 40-80 (Human-like)<br>
-                    • Burstiness: >0.5 (Natural)<br>
-                    • Readability Preserved<br>
-                    • Professional Tone Maintained<br>
-                    • Original Meaning Intact
-                </div>
-                <div style="background: linear-gradient(135deg, #fff3e0, #ffcc80); padding: 20px; border-radius: 15px; border-left: 5px solid #ff9800;">
-                    <strong style="color: #f57c00;">🎯 Detection Bypass Results:</strong><br><br>
-                    • ZeroGPT: <span style="color: #4caf50; font-weight: bold;">0% AI Detection</span><br>
-                    • Quillbot: <span style="color: #4caf50; font-weight: bold;">100% Human</span><br>
-                    • GPTZero: <span style="color: #4caf50; font-weight: bold;">Undetectable</span><br>
-                    • Originality.ai: <span style="color: #4caf50; font-weight: bold;">Bypassed</span><br>
-                    • Copyleaks: <span style="color: #4caf50; font-weight: bold;">Human Content</span><br>
-                    • Turnitin: <span style="color: #4caf50; font-weight: bold;">Original</span>
-                </div>
-            </div>
-        </div>
-        """)
-        
-        gr.HTML("""
-        <div class="feature-card">
-            <h3 style="color: #2c3e50; margin-bottom: 20px;">💡 How It Works - 5-Pass Humanization Process:</h3>
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; margin: 20px 0;">
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #007bff; text-align: center;">
-                    <strong style="color: #007bff;">🔄 Pass 1: Pattern Elimination</strong><br>
-                    Removes AI-flagged words and phrases
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #28a745; text-align: center;">
-                    <strong style="color: #28a745;">🎭 Pass 2: Structure Variation</strong><br>
-                    Restructures sentences naturally
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #ffc107; text-align: center;">
-                    <strong style="color: #e65100;">📚 Pass 3: Vocabulary Enhancement</strong><br>
-                    Replaces with contextual synonyms
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #dc3545; text-align: center;">
-                    <strong style="color: #dc3545;">✨ Pass 4: Human Touches</strong><br>
-                    Adds natural contractions and flow
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #6f42c1; text-align: center;">
-                    <strong style="color: #6f42c1;">🎯 Pass 5: Final Polish</strong><br>
-                    Advanced paraphrasing and optimization
-                </div>
-            </div>
-        </div>
-        """)
-        
-        # Event handlers
-        btn.click(
-            fn=process_text_advanced, 
-            inputs=[input_text, intensity], 
-            outputs=[output_text, analysis]
-        )
-        
-        input_text.submit(
-            fn=process_text_advanced, 
-            inputs=[input_text, intensity], 
-            outputs=[output_text, analysis]
-        )
+    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 interface
-
-if __name__ == "__main__":
-    print("🚀 Starting Advanced AI Humanizer Pro...")
-    app = create_enhanced_interface()
-    app.launch(
-        server_name="0.0.0.0", 
-        server_port=7860, 
-        show_error=True,
-        share=False
-    )
+    return " ".join(capitalized_sentences)
+
+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)
+
+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)
+
+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)
+
+def correct_spelling(text):
+    words = word_tokenize(text)
+    corrected_words = []
+
+    for word in words:
+        corrected_word = spell.candidates(word)
+        if corrected_word:
+            corrected_words.append(spell.candidates(word).pop())  # Choose the first candidate as the correction
+        else:
+            corrected_words.append(word)  # If it's not misspelled, keep the original word
+
+    return ' '.join(corrected_words)
+
+def paraphrase_and_correct(text):
+    paragraphs = text.split("\n\n")  # Split by paragraphs
+
+    # Process each paragraph separately
+    processed_paragraphs = []
+    for paragraph in paragraphs:
+        cleaned_text = remove_redundant_words(paragraph)
+        plag_removed = plagiarism_removal(cleaned_text)
+        paraphrased_text = capitalize_sentences_and_nouns(plag_removed)
+        paraphrased_text = force_first_letter_capital(paraphrased_text)
+        paraphrased_text = correct_article_errors(paraphrased_text)
+        paraphrased_text = correct_tense_errors(paraphrased_text)
+        paraphrased_text = ensure_subject_verb_agreement(paraphrased_text)
+        paraphrased_text = fix_possessives(paraphrased_text)
+        paraphrased_text = correct_spelling(paraphrased_text)  # Spelling correction
+        paraphrased_text = fix_punctuation_spacing(paraphrased_text)
+        processed_paragraphs.append(paraphrased_text)
+
+    return "\n\n".join(processed_paragraphs)  # Reassemble the text with paragraphs
+
+# Gradio app setup
+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')
+
+        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=5, label='Corrected Text')
+
+        button2.click(fn=paraphrase_and_correct, inputs=t2, outputs=result2)
+
+demo.launch(share=True)