Update app.py

app.py

@@ -397,8 +397,8 @@ class SelectiveGrammarFixer:
         
         result = ' '.join(fixed_sentences)
         
-        # Add natural human variations
-        result = self.human_variations.add_natural_human_patterns(result)
+        # Add natural human variations (but we need to reference the main class method)
+        # This will be called from the smart_fix method instead
         
         return result
     
@@ -528,6 +528,120 @@ class EnhancedDipperHumanizer:
         # Initialize human variations handler
         self.human_variations = HumanLikeVariations()
     
+    def add_natural_human_patterns(self, text):
+        """Add natural human writing patterns that Originality AI associates with human text"""
+        sentences = self.split_into_sentences_advanced(text)
+        result_sentences = []
+        
+        for i, sentence in enumerate(sentences):
+            if not sentence.strip():
+                continue
+            
+            # Natural contractions throughout
+            sentence = self.apply_contractions(sentence)
+            
+            # Add natural speech patterns (15% chance)
+            if random.random() < 0.15 and len(sentence.split()) > 10:
+                # Natural interruptions that humans actually use
+                if random.random() < 0.5:
+                    # Add "you know" or "I mean" naturally
+                    words = sentence.split()
+                    if len(words) > 6:
+                        pos = random.randint(3, len(words)-3)
+                        if random.random() < 0.5:
+                            words.insert(pos, "you know,")
+                        else:
+                            words.insert(pos, "I mean,")
+                        sentence = ' '.join(words)
+                else:
+                    # Start with natural opener
+                    openers = ["Look,", "See,", "Thing is,", "Honestly,", "Actually,"]
+                    sentence = random.choice(openers) + " " + sentence[0].lower() + sentence[1:]
+            
+            # Add subtle errors that humans make (8% chance)
+            if random.random() < 0.08:
+                words = sentence.split()
+                if len(words) > 5:
+                    # Common comma omissions
+                    if ", and" in sentence and random.random() < 0.3:
+                        sentence = sentence.replace(", and", " and", 1)
+                    # Double words occasionally
+                    elif random.random() < 0.2:
+                        idx = random.randint(1, len(words)-2)
+                        if words[idx].lower() in ['the', 'a', 'to', 'in', 'on', 'at']:
+                            words.insert(idx+1, words[idx])
+                            sentence = ' '.join(words)
+            
+            # Natural sentence combinations (20% chance)
+            if i < len(sentences) - 1 and random.random() < 0.2:
+                next_sent = sentences[i+1].strip()
+                if next_sent and len(sentence.split()) + len(next_sent.split()) < 25:
+                    # Natural connectors based on content
+                    if any(w in next_sent.lower() for w in ['but', 'however', 'although']):
+                        sentence = sentence.rstrip('.') + ", but " + next_sent[0].lower() + next_sent[1:]
+                        sentences[i+1] = ""  # Mark as processed
+                    elif any(w in next_sent.lower() for w in ['also', 'too', 'as well']):
+                        sentence = sentence.rstrip('.') + " and " + next_sent[0].lower() + next_sent[1:]
+                        sentences[i+1] = ""  # Mark as processed
+            
+            result_sentences.append(sentence)
+        
+        return ' '.join([s for s in result_sentences if s])
+    
+    def vary_sentence_start(self, sentence):
+        """Vary sentence beginning to avoid repetitive patterns"""
+        if not sentence:
+            return sentence
+        
+        words = sentence.split()
+        if len(words) < 5:
+            return sentence
+        
+        # Different ways to start sentences naturally
+        variations = [
+            lambda s: "When " + s[0].lower() + s[1:] + ", it makes sense.",
+            lambda s: "If you think about it, " + s[0].lower() + s[1:],
+            lambda s: s + " This is important.",
+            lambda s: "The thing about " + words[0].lower() + " " + ' '.join(words[1:]) + " is clear.",
+            lambda s: "What's interesting is " + s[0].lower() + s[1:],
+            lambda s: s,  # Keep original sometimes
+        ]
+        
+        # Pick a random variation
+        variation = random.choice(variations)
+        try:
+            return variation(sentence)
+        except:
+            return sentence
+    
+    def apply_contractions(self, text):
+        """Apply common contractions to make text more natural"""
+        contractions = {
+            "it is": "it's", "that is": "that's", "there is": "there's",
+            "he is": "he's", "she is": "she's", "what is": "what's",
+            "where is": "where's", "who is": "who's", "how is": "how's",
+            "cannot": "can't", "will not": "won't", "do not": "don't",
+            "does not": "doesn't", "did not": "didn't", "could not": "couldn't",
+            "should not": "shouldn't", "would not": "wouldn't", "is not": "isn't",
+            "are not": "aren't", "was not": "wasn't", "were not": "weren't",
+            "have not": "haven't", "has not": "hasn't", "had not": "hadn't",
+            "I am": "I'm", "you are": "you're", "we are": "we're",
+            "they are": "they're", "I have": "I've", "you have": "you've",
+            "we have": "we've", "they have": "they've", "I will": "I'll",
+            "you will": "you'll", "he will": "he'll", "she will": "she'll",
+            "we will": "we'll", "they will": "they'll", "I would": "I'd",
+            "you would": "you'd", "he would": "he'd", "she would": "she'd",
+            "we would": "we'd", "they would": "they'd", "could have": "could've",
+            "should have": "should've", "would have": "would've", "might have": "might've",
+            "must have": "must've", "there has": "there's", "here is": "here's",
+            "let us": "let's", "that will": "that'll", "who will": "who'll"
+        }
+        
+        for full, contr in contractions.items():
+            text = re.sub(r'\b' + full + r'\b', contr, text, flags=re.IGNORECASE)
+        
+        return text
+    
     def preserve_keywords(self, text, keywords):
         """Mark keywords to preserve them during paraphrasing"""
         if not keywords: