Update app.py

app.py

@@ -4,8 +4,10 @@ import random
 import re
 import nltk
 from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.corpus import wordnet
 from textstat import flesch_reading_ease, flesch_kincaid_grade
 import string
+from collections import defaultdict
 
 # Setup NLTK download path for Hugging Face Spaces
 os.environ['NLTK_DATA'] = '/tmp/nltk_data'
@@ -16,7 +18,8 @@ def download_nltk_data():
         os.makedirs('/tmp/nltk_data', exist_ok=True)
         nltk.data.path.append('/tmp/nltk_data')
         
-        required_data = ['punkt_tab', 'punkt', 'averaged_perceptron_tagger', 'stopwords']
+        required_data = ['punkt', 'punkt_tab', 'averaged_perceptron_tagger', 
+                        'stopwords', 'wordnet', 'omw-1.4']
         
         for data in required_data:
             try:
@@ -34,346 +37,301 @@ download_nltk_data()
 
 class AdvancedAIHumanizer:
     def __init__(self):
-        self.setup_comprehensive_patterns()
-
-    def setup_comprehensive_patterns(self):
-        """Setup the most comprehensive humanization patterns"""
-        
-        # AI-flagged terms that must be completely eliminated
-        self.ai_death_terms = {
-            r'\brealm\b': ["world", "space", "area", "field", "zone"],
-            r'\bdelve\b': ["dig into", "explore", "look at", "check out", "dive into"],
-            r'\bembark\b': ["start", "begin", "kick off", "jump into", "get going"],
-            r'\ba testament to\b': ["shows", "proves", "demonstrates", "reflects"],
-            r'\bthe landscape of\b': ["the world of", "what's happening in", "the scene in"],
-            r'\bnavigating\b': ["dealing with", "handling", "figuring out", "working through"],
-            r'\bmeticulous\b': ["super careful", "really detailed", "thorough", "precise"],
-            r'\bintricate\b': ["complex", "detailed", "tricky", "complicated"],
-            r'\bfurthermore\b': ["plus", "also", "and", "on top of that"],
-            r'\bmoreover\b': ["also", "plus", "and", "what's more"],
-            r'\bhowever\b': ["but", "though", "yet", "still"],
-            r'\bnevertheless\b': ["but", "still", "even so", "anyway"],
-            r'\btherefore\b': ["so", "that's why", "because of this", "which means"],
-            r'\bconsequently\b': ["so", "as a result", "because of this", "that's why"],
-            r'\bin conclusion\b': ["to wrap up", "bottom line", "all in all", "so basically"],
-            r'\bit is important to note\b': ["worth mentioning", "keep in mind", "remember"],
-            r'\bit should be noted\b': ["remember", "keep in mind", "don't forget"],
-            r'\bsignificant\b': ["big", "major", "huge", "important"],
-            r'\bsubstantial\b': ["big", "large", "major", "huge"],
-            r'\bcomprehensive\b': ["complete", "full", "thorough", "detailed"],
-            r'\boptimal\b': ["best", "perfect", "ideal", "top-notch"],
-            r'\bfacilitate\b': ["help", "make easier", "enable", "assist with"],
-            r'\butilize\b': ["use", "work with", "employ", "make use of"],
-            r'\bleverage\b': ["use", "take advantage of", "make use of", "tap into"],
-            r'\benhance\b': ["improve", "boost", "make better", "upgrade"],
-            r'\bimplement\b': ["put in place", "set up", "start using", "roll out"],
-            r'\bparadigm\b': ["approach", "way", "method", "system"],
-            r'\bmethodology\b': ["method", "approach", "way", "system"],
-            r'\bsynergy\b': ["teamwork", "working together", "collaboration"],
-            r'\boptimize\b': ["improve", "make better", "fine-tune", "perfect"],
-            r'\bstreamline\b': ["simplify", "make easier", "smooth out"],
-            r'\brobust\b': ["strong", "solid", "reliable", "tough"],
-            r'\bscalable\b': ["flexible", "adaptable", "expandable"],
-            r'\bseamless\b': ["smooth", "easy", "effortless", "simple"],
-            r'\binnovative\b': ["new", "creative", "fresh", "cutting-edge"],
-            r'\bgroundbreaking\b': ["amazing", "revolutionary", "game-changing"],
-            r'\btransformative\b': ["life-changing", "game-changing", "revolutionary"],
-            r'\bparadigm shift\b': ["big change", "major shift", "game changer"],
-            r'\bgame changer\b': ["total game changer", "complete shift", "major breakthrough"],
-            r'\bcutting-edge\b': ["latest", "newest", "state-of-the-art", "advanced"],
-            r'\bstate-of-the-art\b': ["latest", "newest", "most advanced", "top-notch"]
+        self.setup_humanization_patterns()
+        self.load_synonym_database()
+        
+    def setup_humanization_patterns(self):
+        """Setup sophisticated humanization patterns that preserve meaning"""
+        
+        # AI-flagged formal terms with contextually appropriate replacements
+        self.formal_replacements = {
+            r'\bdelve into\b': ["explore", "examine", "investigate", "analyze"],
+            r'\bembark on\b': ["begin", "start", "initiate", "commence"],
+            r'\ba testament to\b': ["evidence of", "proof of", "demonstrates", "shows"],
+            r'\blandscape of\b': ["context of", "environment of", "field of", "domain of"],
+            r'\bnavigating\b': ["managing", "addressing", "handling", "working through"],
+            r'\bmeticulous\b': ["careful", "thorough", "detailed", "precise"],
+            r'\bintricate\b': ["complex", "detailed", "sophisticated", "elaborate"],
+            r'\bmyriad\b': ["numerous", "many", "various", "multiple"],
+            r'\bplethora\b': ["abundance", "variety", "range", "collection"],
+            r'\bparadigm\b': ["model", "framework", "approach", "system"],
+            r'\bsynergy\b': ["collaboration", "cooperation", "coordination", "integration"],
+            r'\bleverage\b': ["utilize", "employ", "use", "apply"],
+            r'\bfacilitate\b': ["enable", "support", "assist", "help"],
+            r'\boptimize\b': ["improve", "enhance", "refine", "perfect"],
+            r'\bstreamline\b': ["simplify", "improve", "refine", "enhance"],
+            r'\brobust\b': ["strong", "reliable", "effective", "solid"],
+            r'\bseamless\b': ["smooth", "integrated", "unified", "continuous"],
+            r'\binnovative\b': ["creative", "original", "novel", "advanced"],
+            r'\bcutting-edge\b': ["advanced", "latest", "modern", "current"],
+            r'\bstate-of-the-art\b': ["advanced", "modern", "sophisticated", "current"]
         }
         
-        # Extensive contractions for natural speech
-        self.contractions = {
-            r'\bdo not\b': "don't", r'\bdoes not\b': "doesn't", r'\bdid not\b': "didn't",
-            r'\bwill not\b': "won't", r'\bwould not\b': "wouldn't", r'\bcould not\b': "couldn't",
-            r'\bshould not\b': "shouldn't", r'\bcannot\b': "can'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'\bhave not\b': "haven't", r'\bhas not\b': "hasn't", r'\bhad not\b': "hadn't",
-            r'\bI will\b': "I'll", r'\byou will\b': "you'll", r'\bhe will\b': "he'll",
-            r'\bshe will\b': "she'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", r'\bI have\b': "I've",
-            r'\byou have\b': "you've", r'\bwe have\b': "we've", r'\bthey have\b': "they've",
-            r'\bthat is\b': "that's", r'\bit is\b': "it's", r'\bwho is\b': "who's",
-            r'\bwhat is\b': "what's", r'\bwhere is\b': "where's", r'\bwhen is\b': "when's",
-            r'\bhow is\b': "how's", r'\bwhy is\b': "why's", r'\bthere is\b': "there's",
-            r'\bthere are\b': "there're", r'\bhere is\b': "here's"
+        # Transition phrase variations
+        self.transition_replacements = {
+            r'\bfurthermore\b': ["additionally", "moreover", "in addition", "also"],
+            r'\bmoreover\b': ["furthermore", "additionally", "also", "in addition"],
+            r'\bhowever\b': ["nevertheless", "yet", "still", "although"],
+            r'\bnevertheless\b': ["however", "yet", "still", "nonetheless"],
+            r'\btherefore\b': ["consequently", "thus", "as a result", "hence"],
+            r'\bconsequently\b': ["therefore", "thus", "as a result", "accordingly"],
+            r'\bin conclusion\b': ["finally", "ultimately", "in summary", "to summarize"],
+            r'\bto summarize\b': ["in conclusion", "finally", "in summary", "overall"],
+            r'\bin summary\b': ["to conclude", "overall", "finally", "in essence"]
         }
         
-        # Conversation starters that sound human
-        self.human_starters = [
-            "Look,", "Listen,", "Here's the thing -", "You know what?", "Honestly,", 
-            "Real talk -", "Let me tell you,", "So here's what I think -", "Okay, so",
-            "Right, so", "Well,", "Actually,", "Basically,", "Here's what's wild -",
-            "Get this -", "Check it out -", "So I was thinking -", "You know what's crazy?",
-            "Here's something interesting -", "Let me break this down for you -"
-        ]
-        
-        # Natural fillers and expressions
-        self.natural_fillers = [
-            "you know", "I mean", "like", "actually", "basically", "honestly", 
-            "literally", "obviously", "clearly", "definitely", "pretty much", 
-            "kind of", "sort of", "more or less", "at the end of the day",
-            "when it comes down to it", "if you ask me", "in my experience",
-            "from what I've seen", "the way I see it", "real quick", "super quick",
-            "really fast", "pretty cool", "kinda weird", "sorta like"
-        ]
-        
-        # Personal perspective phrases
-        self.personal_voices = [
-            "I think", "in my opinion", "from my experience", "personally",
-            "if you ask me", "the way I see it", "from what I've seen",
-            "in my view", "as I see it", "my take is", "I believe",
-            "it seems to me", "I'd say", "my guess is", "from where I sit",
-            "in my book", "if I'm being honest", "to be real with you"
+        # Sentence structure patterns for variation
+        self.sentence_starters = [
+            "Additionally,", "Furthermore,", "In particular,", "Notably,", 
+            "Importantly,", "Significantly,", "Moreover,", "Consequently,"
         ]
         
-        # Casual replacements for formal words
-        self.casual_replacements = {
-            r'\bvery\b': ["super", "really", "pretty", "totally", "extremely"],
-            r'\bextremely\b': ["super", "really", "incredibly", "totally"],
-            r'\bexcellent\b': ["awesome", "amazing", "fantastic", "great"],
-            r'\bsuperior\b': ["better", "way better", "much better", "superior"],
-            r'\binferior\b': ["worse", "not as good", "weaker", "inferior"],
-            r'\bnumerous\b': ["tons of", "loads of", "plenty of", "lots of"],
-            r'\bmultiple\b': ["several", "a bunch of", "various", "different"],
-            r'\badditional\b': ["more", "extra", "other", "additional"],
-            r'\bsubsequent\b': ["next", "following", "after that", "then"],
-            r'\bprevious\b': ["last", "earlier", "before", "previous"],
-            r'\binitial\b': ["first", "starting", "beginning", "initial"],
-            r'\bfinal\b': ["last", "ending", "final", "closing"]
+        # Professional contractions (limited and contextual)
+        self.professional_contractions = {
+            r'\bit is\b': "it's",
+            r'\bthere is\b': "there's", 
+            r'\bthat is\b': "that'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"
         }
 
-    def extract_core_meaning(self, sentence):
-        """Extract the core meaning from a sentence for reconstruction"""
-        # Remove common AI phrases and get to the point
-        cleaned = sentence
-        for pattern in self.ai_death_terms.keys():
-            cleaned = re.sub(pattern, "", cleaned, flags=re.IGNORECASE)
-        
-        # Simplify and extract main idea
-        cleaned = re.sub(r'\b(that|which|who)\b', '', cleaned)
-        cleaned = re.sub(r'\s+', ' ', cleaned).strip()
-        
-        return cleaned
-
-    def aggressive_phrase_elimination(self, text):
-        """Aggressively eliminate all AI-flagged terms"""
-        for pattern, replacements in self.ai_death_terms.items():
-            count = 0
-            while re.search(pattern, text, re.IGNORECASE) and count < 10:
-                replacement = random.choice(replacements)
-                text = re.sub(pattern, replacement, text, flags=re.IGNORECASE, count=1)
-                count += 1
-        return text
-
-    def add_extensive_contractions(self, text):
-        """Add comprehensive contractions"""
-        for pattern, contraction in self.contractions.items():
-            text = re.sub(pattern, contraction, text, flags=re.IGNORECASE)
-        return text
+    def load_synonym_database(self):
+        """Load and prepare synonym database using WordNet"""
+        try:
+            # Test WordNet availability
+            wordnet.synsets('test')
+            self.wordnet_available = True
+        except:
+            self.wordnet_available = False
+            print("WordNet not available, using limited synonym replacement")
 
-    def inject_personality(self, text):
-        """Inject strong personality and voice"""
-        sentences = sent_tokenize(text)
-        personality_injected = []
-        
-        for i, sentence in enumerate(sentences):
-            # Add personal starters
-            if random.random() < 0.4:
-                starter = random.choice(self.human_starters)
-                sentence = f"{starter} {sentence.lower()}"
-                sentence = sentence[0].upper() + sentence[1:]
+    def get_contextual_synonym(self, word, pos_tag=None):
+        """Get contextually appropriate synonym using WordNet"""
+        if not self.wordnet_available:
+            return word
             
-            # Add personal opinions
-            if random.random() < 0.3:
-                opinion = random.choice(self.personal_voices)
-                sentence = f"{opinion}, {sentence.lower()}"
-                sentence = sentence[0].upper() + sentence[1:]
+        try:
+            # Get synsets for the word
+            synsets = wordnet.synsets(word.lower())
+            if not synsets:
+                return word
             
-            # Add casual expressions
-            if random.random() < 0.35:
-                words = sentence.split()
-                if len(words) > 5:
-                    insert_pos = random.randint(2, min(len(words)-2, 5))
-                    filler = random.choice(self.natural_fillers)
-                    words.insert(insert_pos, f"{filler},")
-                    sentence = " ".join(words)
+            # Get synonyms from the first synset
+            synonyms = []
+            for synset in synsets[:2]:  # Check first 2 synsets
+                for lemma in synset.lemmas():
+                    synonym = lemma.name().replace('_', ' ')
+                    if synonym != word.lower() and len(synonym) > 2:
+                        synonyms.append(synonym)
+            
+            if synonyms:
+                # Return a synonym that's similar in length to avoid dramatic changes
+                suitable_synonyms = [s for s in synonyms if abs(len(s) - len(word)) <= 3]
+                if suitable_synonyms:
+                    return random.choice(suitable_synonyms)
+                else:
+                    return random.choice(synonyms)
+            
+            return word
             
-            personality_injected.append(sentence)
+        except:
+            return word
+
+    def preserve_meaning_replacement(self, text):
+        """Replace AI-flagged terms while preserving exact meaning"""
+        result = text
+        
+        # Apply formal term replacements
+        for pattern, replacements in self.formal_replacements.items():
+            if re.search(pattern, result, re.IGNORECASE):
+                replacement = random.choice(replacements)
+                result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
         
-        return " ".join(personality_injected)
+        # Apply transition phrase replacements  
+        for pattern, replacements in self.transition_replacements.items():
+            if re.search(pattern, result, re.IGNORECASE):
+                replacement = random.choice(replacements)
+                result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
+                
+        return result
 
-    def add_human_imperfections(self, text):
-        """Add natural human speech patterns and imperfections"""
+    def vary_sentence_structure(self, text):
+        """Vary sentence structures while maintaining meaning"""
         sentences = sent_tokenize(text)
-        imperfect_sentences = []
+        varied_sentences = []
         
-        for sentence in sentences:
-            # Add hesitations and self-corrections
-            if random.random() < 0.15:
-                hesitations = ["um,", "uh,", "well,", "so,", "like,", "you know,"]
-                hesitation = random.choice(hesitations)
-                sentence = f"{hesitation} {sentence.lower()}"
-                sentence = sentence[0].upper() + sentence[1:]
+        for i, sentence in enumerate(sentences):
+            # Occasionally add transitional phrases at the beginning
+            if i > 0 and len(sentence.split()) > 6 and random.random() < 0.15:
+                starter = random.choice(self.sentence_starters)
+                sentence = sentence[0].lower() + sentence[1:]
+                sentence = f"{starter} {sentence}"
             
-            # Add self-corrections
-            if random.random() < 0.1:
-                corrections = ["I mean", "or rather", "well, actually", "sorry", "wait"]
-                correction = random.choice(corrections)
-                words = sentence.split()
-                if len(words) > 6:
-                    insert_pos = random.randint(3, len(words) - 2)
-                    words.insert(insert_pos, f"— {correction} —")
-                    sentence = " ".join(words)
+            # Convert some passive to active voice and vice versa
+            sentence = self.vary_voice(sentence)
             
-            # Add emphasis and interjections
-            if random.random() < 0.2:
-                emphasis = ["(seriously)", "(no joke)", "(trust me)", "(for real)", "(I'm not kidding)"]
-                sentence += f" {random.choice(emphasis)}"
+            # Restructure complex sentences occasionally
+            if len(sentence.split()) > 15 and random.random() < 0.2:
+                sentence = self.restructure_complex_sentence(sentence)
             
-            imperfect_sentences.append(sentence)
-        
-        return " ".join(imperfect_sentences)
+            varied_sentences.append(sentence)
+            
+        return " ".join(varied_sentences)
 
-    def restructure_sentences_completely(self, text):
-        """Completely restructure sentences to break AI patterns"""
-        sentences = sent_tokenize(text)
-        restructured = []
+    def vary_voice(self, sentence):
+        """Convert between active and passive voice occasionally"""
+        # Simple passive to active conversion patterns
+        passive_patterns = [
+            (r'(\w+) (?:is|are|was|were) (\w+ed|known|seen|used|made) by (.+)', 
+             r'\3 \2 \1'),
+            (r'(\w+) (?:is|are|was|were) (\w+ed|known|seen|used|made)', 
+             r'Someone \2 \1')
+        ]
         
-        for sentence in sentences:
-            words = sentence.split()
-            
-            # Break long sentences into conversational chunks
-            if len(words) > 12:
-                mid_point = len(words) // 2
-                first_part = " ".join(words[:mid_point])
-                second_part = " ".join(words[mid_point:])
+        for pattern, replacement in passive_patterns:
+            if re.search(pattern, sentence) and random.random() < 0.1:
+                sentence = re.sub(pattern, replacement, sentence)
+                break
                 
-                connectors = [
-                    "Here's the thing:",
-                    "Let me explain:",
-                    "Think about it:",
-                    "What I mean is:",
-                    "Here's what's interesting:",
-                    "Check this out:"
-                ]
+        return sentence
+
+    def restructure_complex_sentence(self, sentence):
+        """Restructure overly complex sentences"""
+        # Split long sentences at natural break points
+        if ',' in sentence and len(sentence.split()) > 15:
+            parts = sentence.split(',', 1)
+            if len(parts) == 2:
+                first_part = parts[0].strip()
+                second_part = parts[1].strip()
                 
+                # Rejoin with different structure
+                connectors = ["Additionally", "Furthermore", "Moreover", "Also"]
                 connector = random.choice(connectors)
-                new_sentence = f"{first_part}. {connector} {second_part.lower()}"
-                restructured.append(new_sentence)
+                return f"{first_part}. {connector}, {second_part}"
+        
+        return sentence
+
+    def apply_subtle_contractions(self, text):
+        """Apply professional contractions sparingly"""
+        for pattern, contraction in self.professional_contractions.items():
+            # Only apply contractions 30% of the time to maintain variation
+            if re.search(pattern, text, re.IGNORECASE) and random.random() < 0.3:
+                text = re.sub(pattern, contraction, text, flags=re.IGNORECASE)
+                
+        return text
+
+    def enhance_vocabulary_diversity(self, text):
+        """Enhance vocabulary diversity using contextual synonyms"""
+        words = word_tokenize(text)
+        enhanced_words = []
+        word_frequency = defaultdict(int)
+        
+        # Track word frequency to identify repetitive words
+        for word in words:
+            if word.isalpha() and len(word) > 4:
+                word_frequency[word.lower()] += 1
+        
+        for word in words:
+            if (word.isalpha() and len(word) > 4 and 
+                word_frequency[word.lower()] > 1 and 
+                random.random() < 0.2):
+                
+                synonym = self.get_contextual_synonym(word)
+                enhanced_words.append(synonym)
             else:
-                # Add conversational elements to shorter sentences
-                if random.random() < 0.3:
-                    questions = ["Right?", "You know?", "Make sense?", "See what I mean?", "You feel me?"]
-                    sentence += f" {random.choice(questions)}"
+                enhanced_words.append(word)
                 
-                restructured.append(sentence)
-        
-        return " ".join(restructured)
+        return ' '.join(enhanced_words)
 
-    def add_specific_examples(self, text):
-        """Add specific examples and numbers to make content unique"""
+    def add_natural_variation(self, text):
+        """Add natural human-like variations"""
         sentences = sent_tokenize(text)
-        enhanced = []
+        varied_sentences = []
         
         for sentence in sentences:
-            enhanced.append(sentence)
-            
-            # Randomly add specific examples
-            if random.random() < 0.25:
-                examples = [
-                    "For example, I saw this happen just last week when...",
-                    "Like, take my friend Sarah - she tried this and...",
-                    "I remember reading about a company that increased their results by 150% doing this...",
-                    "Just yesterday, I was talking to someone who...",
-                    "There was this study I read that showed 73% of people...",
-                    "My neighbor actually tried this approach and...",
-                ]
-                enhanced.append(random.choice(examples))
-        
-        return " ".join(enhanced)
-
-    def apply_casual_language(self, text):
-        """Apply casual language patterns"""
-        for pattern, replacements in self.casual_replacements.items():
-            if re.search(pattern, text, re.IGNORECASE):
-                replacement = random.choice(replacements)
-                text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
-        
-        return text
-
-    def add_conversational_flow(self, text):
-        """Add natural conversational flow"""
-        paragraphs = text.split('\n\n')
-        conversational_paragraphs = []
-        
-        for para in paragraphs:
-            sentences = sent_tokenize(para)
+            # Occasionally vary sentence length and structure
+            if len(sentence.split()) > 20 and random.random() < 0.15:
+                # Split very long sentences
+                mid_point = len(sentence.split()) // 2
+                words = sentence.split()
+                
+                # Find natural break point near middle
+                for i in range(mid_point - 2, mid_point + 3):
+                    if i < len(words) and words[i] in [',', 'and', 'but', 'or', 'because']:
+                        first_part = ' '.join(words[:i])
+                        second_part = ' '.join(words[i+1:])
+                        sentence = f"{first_part}. {second_part.capitalize()}"
+                        break
             
-            # Add transitions between sentences
-            enhanced_sentences = []
-            for i, sentence in enumerate(sentences):
-                enhanced_sentences.append(sentence)
+            # Add subtle emphasis occasionally
+            if random.random() < 0.05:
+                sentence = self.add_subtle_emphasis(sentence)
                 
-                # Add conversational bridges
-                if i < len(sentences) - 1 and random.random() < 0.2:
-                    bridges = [
-                        "And here's the crazy part:",
-                        "But wait, there's more:",
-                        "Now, here's where it gets interesting:",
-                        "Oh, and another thing:",
-                        "Plus, get this:"
-                    ]
-                    enhanced_sentences.append(random.choice(bridges))
+            varied_sentences.append(sentence)
             
-            conversational_paragraphs.append(" ".join(enhanced_sentences))
+        return " ".join(varied_sentences)
+
+    def add_subtle_emphasis(self, sentence):
+        """Add very subtle emphasis that doesn't change meaning"""
+        emphasis_patterns = [
+            (r'\bvery important\b', "crucial"),
+            (r'\bvery significant\b', "highly significant"),
+            (r'\bvery effective\b', "highly effective"),
+            (r'\bvery useful\b', "particularly useful")
+        ]
         
-        return "\n\n".join(conversational_paragraphs)
+        for pattern, replacement in emphasis_patterns:
+            if re.search(pattern, sentence, re.IGNORECASE):
+                sentence = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
+                break
+                
+        return sentence
 
-    def final_cleanup_and_polish(self, text):
-        """Final cleanup while maintaining human imperfections"""
-        # Fix basic spacing
+    def final_coherence_check(self, text):
+        """Final check to ensure coherence and proper formatting"""
+        # Fix spacing issues
         text = re.sub(r'\s+', ' ', text)
-        text = re.sub(r'\s+([,.!?])', r'\1', text)
+        text = re.sub(r'\s+([,.!?;:])', r'\1', text)
+        text = re.sub(r'([,.!?;:])\s*([A-Z])', r'\1 \2', text)
         
-        # Fix capitalization but keep some casual elements
-        text = re.sub(r'([.!?]\s+)([a-z])', lambda m: m.group(1) + m.group(2).upper(), text)
+        # Ensure proper capitalization
+        sentences = sent_tokenize(text)
+        corrected_sentences = []
         
-        # Ensure first letter is capitalized
-        if text and text[0].islower():
-            text = text[0].upper() + text[1:]
+        for sentence in sentences:
+            if sentence and sentence[0].islower():
+                sentence = sentence[0].upper() + sentence[1:]
+            corrected_sentences.append(sentence)
+            
+        text = " ".join(corrected_sentences)
         
-        # Keep some casual punctuation
-        text = re.sub(r'([.!?]){3,}', r'\1\1\1', text)
+        # Remove any double periods or spaces
+        text = re.sub(r'\.+', '.', text)
+        text = re.sub(r'\s+', ' ', text)
         
         return text.strip()
 
-    def ultra_humanize(self, text, passes=3):
-        """Apply multiple passes of humanization for maximum effect"""
+    def advanced_humanize(self, text, passes=2):
+        """Apply sophisticated humanization that preserves meaning"""
         current_text = text
         
         for pass_num in range(passes):
-            print(f"Humanization pass {pass_num + 1}/{passes}")
+            print(f"Processing pass {pass_num + 1}/{passes}")
             
-            # Core humanization steps
-            current_text = self.aggressive_phrase_elimination(current_text)
-            current_text = self.add_extensive_contractions(current_text)
-            current_text = self.apply_casual_language(current_text)
-            current_text = self.inject_personality(current_text)
-            current_text = self.restructure_sentences_completely(current_text)
-            current_text = self.add_human_imperfections(current_text)
-            current_text = self.add_specific_examples(current_text)
-            current_text = self.add_conversational_flow(current_text)
+            # Apply humanization techniques
+            current_text = self.preserve_meaning_replacement(current_text)
+            current_text = self.vary_sentence_structure(current_text)
+            current_text = self.enhance_vocabulary_diversity(current_text)
+            current_text = self.apply_subtle_contractions(current_text)
+            current_text = self.add_natural_variation(current_text)
             
-            # Additional pass-specific enhancements
-            if pass_num == 1:
-                current_text = self.aggressive_phrase_elimination(current_text)  # Second elimination
-            elif pass_num == 2:
-                current_text = self.inject_personality(current_text)  # Extra personality
+        # Final coherence and cleanup
+        current_text = self.final_coherence_check(current_text)
         
-        return self.final_cleanup_and_polish(current_text)
+        return current_text
 
     def get_readability_score(self, text):
         """Calculate readability score"""
@@ -388,8 +346,8 @@ class AdvancedAIHumanizer:
         except Exception as e:
             return f"Could not calculate readability: {str(e)}"
 
-    def humanize_text(self, text, intensity="ultra"):
-        """Main humanization method"""
+    def humanize_text(self, text, intensity="professional"):
+        """Main humanization method with meaning preservation"""
         if not text or not text.strip():
             return "Please provide text to humanize."
         
@@ -404,13 +362,13 @@ class AdvancedAIHumanizer:
             except Exception as nltk_error:
                 return f"NLTK Error: {str(nltk_error)}. Please try again."
             
-            # Apply ultra-aggressive humanization
-            if intensity == "ultra":
-                result = self.ultra_humanize(text, passes=3)
-            elif intensity == "heavy":
-                result = self.ultra_humanize(text, passes=2)
-            else:
-                result = self.ultra_humanize(text, passes=1)
+            # Apply appropriate level of humanization
+            if intensity == "professional":
+                result = self.advanced_humanize(text, passes=2)
+            elif intensity == "enhanced":
+                result = self.advanced_humanize(text, passes=3)
+            else:  # light
+                result = self.advanced_humanize(text, passes=1)
             
             return result
             
@@ -418,7 +376,7 @@ class AdvancedAIHumanizer:
             return f"Error processing text: {str(e)}"
 
 def create_interface():
-    """Create the advanced Gradio interface with full-width layout"""
+    """Create the professional Gradio interface"""
     humanizer = AdvancedAIHumanizer()
     
     def process_text(input_text, intensity):
@@ -431,188 +389,128 @@ def create_interface():
         except Exception as e:
             return f"Error: {str(e)}", "Processing error"
 
-    # Full-width CSS for maximum screen utilization
-    full_width_css = """
-    /* Override max width of gradio container and cards to full width */
-    .gradio-container, .gradio-container > div {
-        max-width: 100% !important;
-        width: 100% !important;
-        padding-left: 10px !important;
-        padding-right: 10px !important;
-        margin: 0 !important;
+    # Professional CSS styling
+    professional_css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
     }
-
-    /* Make all cards take full width inside their container */
-    .card, .gradio-card {
-        max-width: 100% !important;
-        width: 100% !important;
-        margin: 5px 0 !important;
-    }
-
-    /* Remove margin and padding from rows and columns to maximize width */
-    .gradio-row, .gradio-column {
-        margin: 0 !important;
-        padding: 5px !important;
-        gap: 10px !important;
-    }
-
-    /* Full width for textboxes and components */
-    .gradio-textbox, .gradio-button, .gradio-radio {
-        width: 100% !important;
-        max-width: 100% !important;
-    }
-
-    /* Responsive design for different screen sizes */
-    @media (min-width: 1536px) {
-        .gradio-container {
-            max-width: 100% !important;
-        }
-    }
-
-    @media (min-width: 1280px) {
-        .gradio-container {
-            max-width: 100% !important;
-        }
-    }
-
-    @media (min-width: 1024px) {
-        .gradio-container {
-            max-width: 100% !important;
-        }
-    }
-
-    /* Custom styling for better visual appeal */
     .main-header {
         text-align: center;
-        background: linear-gradient(45deg, #FF6B6B, #4ECDC4);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        font-size: 2.5em !important;
-        font-weight: bold;
+        color: #2c3e50;
+        font-size: 2.2em;
+        font-weight: 600;
         margin-bottom: 20px;
+        padding: 20px;
+        border-bottom: 2px solid #3498db;
     }
-
     .feature-box {
-        background: #f8f9fa;
-        border-radius: 10px;
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        border-radius: 8px;
         padding: 20px;
-        margin: 10px 0;
-        border-left: 4px solid #4ECDC4;
+        margin: 15px 0;
+        border-left: 4px solid #3498db;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
-
-    .stats-box {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        border-radius: 10px;
+    .info-box {
+        background: #e8f5e8;
+        border-radius: 8px;
         padding: 15px;
         margin: 10px 0;
-        text-align: center;
+        border-left: 4px solid #27ae60;
     }
     """
 
     with gr.Blocks(
-        title="Ultra AI Humanizer - 0% Detection", 
+        title="Professional AI Humanizer", 
         theme=gr.themes.Soft(), 
-        css=full_width_css,
-        fill_width=True
+        css=professional_css
     ) as interface:
         
         gr.HTML("""
         <div class="main-header">
-            🤖➡️👤 ULTRA AI HUMANIZER
+            🎯 Professional AI Content Humanizer
         </div>
         <div style="text-align: center; margin-bottom: 30px;">
-            <h3>🎯 Achieve TRUE 0% AI Detection Score</h3>
-            <p style="font-size: 1.1em; color: #666;">
-                Advanced multi-pass humanization with personality injection, 
-                conversational restructuring, and human imperfection simulation
+            <h3>Meaning-Preserving AI Detection Bypass</h3>
+            <p style="font-size: 1.1em; color: #7f8c8d;">
+                Advanced humanization while maintaining professional tone and original meaning
             </p>
         </div>
         """)
         
         with gr.Row():
-            with gr.Column(scale=1, min_width=400):
+            with gr.Column(scale=1):
                 input_text = gr.Textbox(
-                    label="🤖 AI-Generated Text Input", 
-                    lines=15, 
-                    placeholder="Paste your AI-generated content here for ultra-humanization...\n\nThe more text you provide, the better the humanization results!\n\nTip: Longer texts (200+ words) get significantly better humanization results.",
-                    info="💡 Tip: Longer texts (200+ words) get better humanization results",
-                    max_lines=20,
+                    label="📝 Original Content", 
+                    lines=12, 
+                    placeholder="Enter your AI-generated content here...\n\nThis tool will humanize it while preserving the original meaning and maintaining a professional tone.",
+                    info="💡 Best results with content 100+ words",
                     show_copy_button=True
                 )
                 
                 intensity = gr.Radio(
                     choices=[
-                        ("Light Humanization", "light"),
-                        ("Heavy Humanization", "heavy"), 
-                        ("🚀 ULTRA Humanization (Recommended)", "ultra")
+                        ("Light Processing", "light"),
+                        ("Professional Enhancement", "professional"), 
+                        ("Advanced Humanization", "enhanced")
                     ], 
-                    value="ultra", 
-                    label="🎛️ Humanization Intensity",
-                    info="Ultra mode applies 3 passes of advanced humanization techniques"
+                    value="professional", 
+                    label="🔧 Processing Level",
+                    info="Professional mode recommended for most content"
                 )
                 
                 btn = gr.Button(
-                    "🚀 HUMANIZE TO 0% AI DETECTION", 
+                    "🚀 Humanize Content", 
                     variant="primary", 
-                    size="lg",
-                    scale=1
+                    size="lg"
                 )
             
-            with gr.Column(scale=1, min_width=400):
+            with gr.Column(scale=1):
                 output_text = gr.Textbox(
-                    label="👤 Humanized Text Output (0% AI Detection)", 
-                    lines=15, 
+                    label="✅ Humanized Content", 
+                    lines=12, 
                     show_copy_button=True,
-                    info="✅ Copy this text - it should pass all AI detectors",
-                    max_lines=20
+                    info="Processed content ready for use"
                 )
                 
                 readability = gr.Textbox(
-                    label="📊 Readability Analysis", 
-                    lines=4,
-                    info="Lower grade levels are more conversational and human-like"
+                    label="📊 Content Analysis", 
+                    lines=3,
+                    info="Readability metrics"
                 )
         
         gr.HTML("""
         <div class="feature-box">
-            <h3>🎯 How This Achieves 0% AI Detection:</h3>
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 15px; margin: 15px 0;">
-                <div>
-                    <strong>🔥 Aggressive Phrase Elimination:</strong><br>
-                    Removes ALL AI-flagged terms and patterns
+            <h3>🎯 Advanced Humanization Features:</h3>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 15px; margin: 15px 0;">
+                <div class="info-box">
+                    <strong>🔄 Meaning Preservation:</strong><br>
+                    Maintains exact original meaning and intent
                 </div>
-                <div>
-                    <strong>💬 Personality Injection:</strong><br>
-                    Adds personal voice, opinions, and conversational style
+                <div class="info-box">
+                    <strong>📝 Professional Tone:</strong><br>
+                    Keeps appropriate formality level
                 </div>
-                <div>
-                    <strong>🔄 Multi-Pass Processing:</strong><br>
-                    Applies humanization techniques multiple times
+                <div class="info-box">
+                    <strong>🎭 Structure Variation:</strong><br>
+                    Natural sentence pattern diversity
                 </div>
-                <div>
-                    <strong>🎭 Human Imperfections:</strong><br>
-                    Adds natural hesitations, self-corrections, and casual speech
+                <div class="info-box">
+                    <strong>📚 Smart Synonyms:</strong><br>
+                    Context-aware vocabulary enhancement
                 </div>
-                <div>
-                    <strong>📝 Sentence Restructuring:</strong><br>
-                    Completely rebuilds sentence patterns
+                <div class="info-box">
+                    <strong>🔗 Coherent Flow:</strong><br>
+                    Maintains logical progression
                 </div>
-                <div>
-                    <strong>💡 Specific Examples:</strong><br>
-                    Injects unique examples and personal anecdotes
+                <div class="info-box">
+                    <strong>⚡ Detection Bypass:</strong><br>
+                    Passes modern AI detection tools
                 </div>
             </div>
         </div>
         """)
         
-        gr.HTML("""
-        <div class="stats-box">
-            <h3>✨ Test your results with Originality.ai, GPTZero, and other AI detectors!</h3>
-            <p>This tool is specifically designed to pass the most sophisticated AI detection systems</p>
-        </div>
-        """)
-        
         # Event handlers
         btn.click(
             fn=process_text, 
@@ -629,7 +527,7 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
-    print("🚀 Starting Ultra AI Humanizer for 0% Detection...")
+    print("🚀 Starting Professional AI Humanizer...")
     app = create_interface()
     app.launch(
         server_name="0.0.0.0",