Update app.py

app.py

@@ -45,45 +45,46 @@ class AdvancedAIHumanizer:
         
         # 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"]
+            r'\bdelve into\b': ["explore", "examine", "investigate", "analyze", "look into"],
+            r'\bembark on\b': ["begin", "start", "initiate", "commence", "launch"],
+            r'\ba testament to\b': ["evidence of", "proof of", "demonstrates", "shows", "indicates"],
+            r'\blandscape of\b': ["context of", "environment of", "field of", "domain of", "realm of"],
+            r'\bnavigating\b': ["managing", "addressing", "handling", "working through", "dealing with"],
+            r'\bmeticulous\b': ["careful", "thorough", "detailed", "precise", "systematic"],
+            r'\bintricate\b': ["complex", "detailed", "sophisticated", "elaborate", "nuanced"],
+            r'\bmyriad\b': ["numerous", "many", "various", "multiple", "countless"],
+            r'\bplethora\b': ["abundance", "variety", "range", "collection", "wealth"],
+            r'\bparadigm\b': ["model", "framework", "approach", "system", "method"],
+            r'\bsynergy\b': ["collaboration", "cooperation", "coordination", "integration", "teamwork"],
+            r'\bleverage\b': ["utilize", "employ", "use", "apply", "harness"],
+            r'\bfacilitate\b': ["enable", "support", "assist", "help", "promote"],
+            r'\boptimize\b': ["improve", "enhance", "refine", "perfect", "maximize"],
+            r'\bstreamline\b': ["simplify", "improve", "refine", "enhance", "optimize"],
+            r'\brobust\b': ["strong", "reliable", "effective", "solid", "durable"],
+            r'\bseamless\b': ["smooth", "integrated", "unified", "continuous", "fluid"],
+            r'\binnovative\b': ["creative", "original", "novel", "advanced", "groundbreaking"],
+            r'\bcutting-edge\b': ["advanced", "latest", "modern", "current", "state-of-the-art"],
+            r'\bstate-of-the-art\b': ["advanced", "modern", "sophisticated", "current", "latest"]
         }
         
         # 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"]
+            r'\bfurthermore\b': ["additionally", "moreover", "in addition", "also", "besides"],
+            r'\bmoreover\b': ["furthermore", "additionally", "also", "in addition", "what's more"],
+            r'\bhowever\b': ["nevertheless", "yet", "still", "although", "but"],
+            r'\bnevertheless\b': ["however", "yet", "still", "nonetheless", "even so"],
+            r'\btherefore\b': ["consequently", "thus", "as a result", "hence", "so"],
+            r'\bconsequently\b': ["therefore", "thus", "as a result", "accordingly", "hence"],
+            r'\bin conclusion\b': ["finally", "ultimately", "in summary", "to summarize", "overall"],
+            r'\bto summarize\b': ["in conclusion", "finally", "in summary", "overall", "in essence"],
+            r'\bin summary\b': ["to conclude", "overall", "finally", "in essence", "ultimately"]
         }
         
         # Sentence structure patterns for variation
         self.sentence_starters = [
             "Additionally,", "Furthermore,", "In particular,", "Notably,", 
-            "Importantly,", "Significantly,", "Moreover,", "Consequently,"
+            "Importantly,", "Significantly,", "Moreover,", "Consequently,",
+            "Interestingly,", "Specifically,", "Essentially,", "Primarily,"
         ]
         
         # Professional contractions (limited and contextual)
@@ -95,7 +96,9 @@ class AdvancedAIHumanizer:
             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'\bwould not\b': "wouldn't",
+            r'\bshould not\b': "shouldn't",
+            r'\bcould not\b': "couldn't"
         }
 
     def load_synonym_database(self):
@@ -104,6 +107,7 @@ class AdvancedAIHumanizer:
             # Test WordNet availability
             wordnet.synsets('test')
             self.wordnet_available = True
+            print("WordNet loaded successfully")
         except:
             self.wordnet_available = False
             print("WordNet not available, using limited synonym replacement")
@@ -140,41 +144,60 @@ class AdvancedAIHumanizer:
         except:
             return word
 
-    def preserve_meaning_replacement(self, text):
+    def preserve_meaning_replacement(self, text, intensity_level=1):
         """Replace AI-flagged terms while preserving exact meaning"""
         result = text
         
+        # Determine replacement probability based on intensity
+        replacement_probability = {
+            1: 0.3,  # Light
+            2: 0.5,  # Standard  
+            3: 0.7   # Heavy
+        }
+        
+        prob = replacement_probability.get(intensity_level, 0.5)
+        
         # Apply formal term replacements
         for pattern, replacements in self.formal_replacements.items():
-            if re.search(pattern, result, re.IGNORECASE):
+            if re.search(pattern, result, re.IGNORECASE) and random.random() < prob:
                 replacement = random.choice(replacements)
                 result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
         
         # Apply transition phrase replacements  
         for pattern, replacements in self.transition_replacements.items():
-            if re.search(pattern, result, re.IGNORECASE):
+            if re.search(pattern, result, re.IGNORECASE) and random.random() < prob:
                 replacement = random.choice(replacements)
                 result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
                 
         return result
 
-    def vary_sentence_structure(self, text):
+    def vary_sentence_structure(self, text, intensity_level=1):
         """Vary sentence structures while maintaining meaning"""
         sentences = sent_tokenize(text)
         varied_sentences = []
         
+        # Determine variation probability based on intensity
+        variation_probability = {
+            1: 0.1,  # Light
+            2: 0.2,  # Standard
+            3: 0.3   # Heavy
+        }
+        
+        prob = variation_probability.get(intensity_level, 0.2)
+        
         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:
+            if i > 0 and len(sentence.split()) > 6 and random.random() < prob:
                 starter = random.choice(self.sentence_starters)
                 sentence = sentence[0].lower() + sentence[1:]
                 sentence = f"{starter} {sentence}"
             
             # Convert some passive to active voice and vice versa
-            sentence = self.vary_voice(sentence)
+            if random.random() < prob:
+                sentence = self.vary_voice(sentence)
             
             # Restructure complex sentences occasionally
-            if len(sentence.split()) > 15 and random.random() < 0.2:
+            if len(sentence.split()) > 15 and random.random() < prob:
                 sentence = self.restructure_complex_sentence(sentence)
             
             varied_sentences.append(sentence)
@@ -192,7 +215,7 @@ class AdvancedAIHumanizer:
         ]
         
         for pattern, replacement in passive_patterns:
-            if re.search(pattern, sentence) and random.random() < 0.1:
+            if re.search(pattern, sentence) and random.random() < 0.3:
                 sentence = re.sub(pattern, replacement, sentence)
                 break
                 
@@ -214,21 +237,38 @@ class AdvancedAIHumanizer:
         
         return sentence
 
-    def apply_subtle_contractions(self, text):
+    def apply_subtle_contractions(self, text, intensity_level=1):
         """Apply professional contractions sparingly"""
+        # Determine contraction probability based on intensity
+        contraction_probability = {
+            1: 0.2,  # Light
+            2: 0.3,  # Standard
+            3: 0.4   # Heavy
+        }
+        
+        prob = contraction_probability.get(intensity_level, 0.3)
+        
         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:
+            if re.search(pattern, text, re.IGNORECASE) and random.random() < prob:
                 text = re.sub(pattern, contraction, text, flags=re.IGNORECASE)
                 
         return text
 
-    def enhance_vocabulary_diversity(self, text):
+    def enhance_vocabulary_diversity(self, text, intensity_level=1):
         """Enhance vocabulary diversity using contextual synonyms"""
         words = word_tokenize(text)
         enhanced_words = []
         word_frequency = defaultdict(int)
         
+        # Determine synonym probability based on intensity
+        synonym_probability = {
+            1: 0.1,  # Light
+            2: 0.2,  # Standard
+            3: 0.3   # Heavy
+        }
+        
+        prob = synonym_probability.get(intensity_level, 0.2)
+        
         # Track word frequency to identify repetitive words
         for word in words:
             if word.isalpha() and len(word) > 4:
@@ -237,7 +277,7 @@ class AdvancedAIHumanizer:
         for word in words:
             if (word.isalpha() and len(word) > 4 and 
                 word_frequency[word.lower()] > 1 and 
-                random.random() < 0.2):
+                random.random() < prob):
                 
                 synonym = self.get_contextual_synonym(word)
                 enhanced_words.append(synonym)
@@ -246,14 +286,23 @@ class AdvancedAIHumanizer:
                 
         return ' '.join(enhanced_words)
 
-    def add_natural_variation(self, text):
+    def add_natural_variation(self, text, intensity_level=1):
         """Add natural human-like variations"""
         sentences = sent_tokenize(text)
         varied_sentences = []
         
+        # Determine variation probability based on intensity
+        variation_probability = {
+            1: 0.05,  # Light
+            2: 0.15,  # Standard
+            3: 0.25   # Heavy
+        }
+        
+        prob = variation_probability.get(intensity_level, 0.15)
+        
         for sentence in sentences:
             # Occasionally vary sentence length and structure
-            if len(sentence.split()) > 20 and random.random() < 0.15:
+            if len(sentence.split()) > 20 and random.random() < prob:
                 # Split very long sentences
                 mid_point = len(sentence.split()) // 2
                 words = sentence.split()
@@ -267,7 +316,7 @@ class AdvancedAIHumanizer:
                         break
             
             # Add subtle emphasis occasionally
-            if random.random() < 0.05:
+            if random.random() < prob:
                 sentence = self.add_subtle_emphasis(sentence)
                 
             varied_sentences.append(sentence)
@@ -280,7 +329,9 @@ class AdvancedAIHumanizer:
             (r'\bvery important\b', "crucial"),
             (r'\bvery significant\b', "highly significant"),
             (r'\bvery effective\b', "highly effective"),
-            (r'\bvery useful\b', "particularly useful")
+            (r'\bvery useful\b', "particularly useful"),
+            (r'\bvery good\b', "excellent"),
+            (r'\bvery bad\b', "poor")
         ]
         
         for pattern, replacement in emphasis_patterns:
@@ -314,20 +365,19 @@ class AdvancedAIHumanizer:
         
         return text.strip()
 
-    def advanced_humanize(self, text, passes=2):
+    def advanced_humanize(self, text, intensity_level=1):
         """Apply sophisticated humanization that preserves meaning"""
         current_text = text
         
-        for pass_num in range(passes):
-            print(f"Processing pass {pass_num + 1}/{passes}")
-            
-            # 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)
-            
+        print(f"Processing with intensity level: {intensity_level}")
+        
+        # Apply humanization techniques with intensity-based parameters
+        current_text = self.preserve_meaning_replacement(current_text, intensity_level)
+        current_text = self.vary_sentence_structure(current_text, intensity_level)
+        current_text = self.enhance_vocabulary_diversity(current_text, intensity_level)
+        current_text = self.apply_subtle_contractions(current_text, intensity_level)
+        current_text = self.add_natural_variation(current_text, intensity_level)
+        
         # Final coherence and cleanup
         current_text = self.final_coherence_check(current_text)
         
@@ -346,7 +396,7 @@ class AdvancedAIHumanizer:
         except Exception as e:
             return f"Could not calculate readability: {str(e)}"
 
-    def humanize_text(self, text, intensity="professional"):
+    def humanize_text(self, text, intensity="standard"):
         """Main humanization method with meaning preservation"""
         if not text or not text.strip():
             return "Please provide text to humanize."
@@ -362,13 +412,18 @@ class AdvancedAIHumanizer:
             except Exception as nltk_error:
                 return f"NLTK Error: {str(nltk_error)}. Please try again."
             
-            # 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)
+            # Map intensity to numeric levels
+            intensity_mapping = {
+                "light": 1,
+                "standard": 2,
+                "heavy": 3
+            }
+            
+            intensity_level = intensity_mapping.get(intensity, 2)
+            print(f"Using intensity: {intensity} (level {intensity_level})")
+            
+            # Apply humanization
+            result = self.advanced_humanize(text, intensity_level)
             
             return result
             
@@ -450,13 +505,13 @@ def create_interface():
                 
                 intensity = gr.Radio(
                     choices=[
-                        ("Light Processing", "light"),
-                        ("Professional Enhancement", "professional"), 
-                        ("Advanced Humanization", "enhanced")
+                        ("Light Processing (30% changes)", "light"),
+                        ("Standard Processing (50% changes)", "standard"), 
+                        ("Heavy Processing (70% changes)", "heavy")
                     ], 
-                    value="professional", 
-                    label="🔧 Processing Level",
-                    info="Professional mode recommended for most content"
+                    value="standard", 
+                    label="🔧 Processing Intensity",
+                    info="Choose how extensively to humanize the content"
                 )
                 
                 btn = gr.Button(
@@ -481,7 +536,36 @@ def create_interface():
         
         gr.HTML("""
         <div class="feature-box">
-            <h3>🎯 Advanced Humanization Features:</h3>
+            <h3>🎯 Processing Intensity Levels:</h3>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 15px; margin: 15px 0;">
+                <div class="info-box">
+                    <strong>🟢 Light Processing (30%):</strong><br>
+                    • Minimal word replacements<br>
+                    • Basic sentence variation<br>
+                    • Subtle changes only<br>
+                    • Best for: Already human-like content
+                </div>
+                <div class="info-box">
+                    <strong>🟡 Standard Processing (50%):</strong><br>
+                    • Moderate humanization<br>
+                    • Balanced approach<br>
+                    • Professional tone maintained<br>
+                    • Best for: Most AI-generated content
+                </div>
+                <div class="info-box">
+                    <strong>🔴 Heavy Processing (70%):</strong><br>
+                    • Extensive modifications<br>
+                    • Maximum variation<br>
+                    • Strong AI detection bypass<br>
+                    • Best for: Highly detectable AI text
+                </div>
+            </div>
+        </div>
+        """)
+        
+        gr.HTML("""
+        <div class="feature-box">
+            <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>