Update app.py

app.py

@@ -3,222 +3,274 @@ import random
 import re
 import nltk
 from nltk.tokenize import sent_tokenize, word_tokenize
-from nltk.corpus import stopwords
-from nltk.tag import pos_tag
 import string
 from textstat import flesch_reading_ease, flesch_kincaid_grade
-import spacy
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
-import torch
 
 # Download required NLTK data
 try:
     nltk.download('punkt', quiet=True)
     nltk.download('averaged_perceptron_tagger', quiet=True)
     nltk.download('stopwords', quiet=True)
-    nltk.download('wordnet', quiet=True)
-except:
-    pass
+    print("NLTK data downloaded successfully")
+except Exception as e:
+    print(f"NLTK download error: {e}")
 
 class AIContentHumanizer:
     def __init__(self):
-        self.setup_models()
         self.setup_humanization_patterns()
         
-    def setup_models(self):
-        """Initialize AI detection and paraphrasing models"""
-        try:
-            # Load spaCy model
-            self.nlp = spacy.load("en_core_web_sm")
-        except:
-            # Fallback if spaCy model not available
-            self.nlp = None
-            
-        # Paraphrasing patterns and synonyms
-        self.synonyms = {
-            'however': ['but', 'yet', 'though', 'nevertheless', 'still'],
-            'therefore': ['so', 'thus', 'hence', 'as a result', 'consequently'],
-            'furthermore': ['also', 'moreover', 'additionally', 'besides', 'plus'],
-            'nevertheless': ['however', 'yet', 'still', 'but', 'though'],
-            'consequently': ['therefore', 'so', 'thus', 'as a result', 'hence'],
-            'significant': ['important', 'major', 'notable', 'considerable', 'substantial'],
-            'utilize': ['use', 'employ', 'apply', 'make use of', 'take advantage of'],
-            'demonstrate': ['show', 'prove', 'display', 'exhibit', 'reveal'],
-            'numerous': ['many', 'several', 'various', 'countless', 'multiple'],
-            'substantial': ['significant', 'considerable', 'large', 'major', 'important']
-        }
-    
     def setup_humanization_patterns(self):
         """Setup patterns for humanizing text"""
-        self.ai_phrases = [
-            r'\b(it is important to note that|it should be noted that|it is worth noting that)\b',
-            r'\b(in conclusion|to conclude|in summary|to summarize)\b',
-            r'\b(furthermore|moreover|additionally|in addition)\b',
-            r'\b(however|nevertheless|nonetheless|on the other hand)\b',
-            r'\b(therefore|consequently|as a result|thus)\b',
-            r'\b(various|numerous|several|multiple)\b',
-            r'\b(significant|substantial|considerable|notable)\b',
-            r'\b(utilize|implement|demonstrate|facilitate)\b'
-        ]
         
-        self.human_replacements = {
-            'it is important to note that': ['worth mentioning', 'notably', 'interestingly'],
-            'it should be noted that': ['keep in mind', 'remember', 'note that'],
-            'furthermore': ['also', 'plus', 'what\'s more', 'on top of that'],
-            'moreover': ['also', 'besides', 'what\'s more', 'and'],
-            'however': ['but', 'though', 'yet', 'still'],
-            'therefore': ['so', 'that\'s why', 'which means'],
-            'consequently': ['so', 'as a result', 'that\'s why'],
-            'numerous': ['many', 'lots of', 'plenty of', 'tons of'],
-            'significant': ['big', 'major', 'important', 'key'],
-            'utilize': ['use', 'make use of', 'work with'],
-            'demonstrate': ['show', 'prove', 'make clear'],
-            'facilitate': ['help', 'make easier', 'enable']
+        # AI-typical phrases and their human alternatives
+        self.ai_replacements = {
+            r'\bit is important to note that\b': [
+                "worth mentioning that", "keep in mind that", "note that",
+                "interestingly,", "what's notable is that", "by the way,"
+            ],
+            r'\bit should be noted that\b': [
+                "remember that", "worth noting that", "keep in mind",
+                "importantly,", "note that", "just so you know,"
+            ],
+            r'\bin conclusion\b': [
+                "to wrap up", "all in all", "bottom line",
+                "so basically", "in the end", "overall", "to sum it up"
+            ],
+            r'\bto conclude\b': [
+                "to wrap up", "all in all", "in the end",
+                "so basically", "overall", "final thoughts"
+            ],
+            r'\bfurthermore\b': [
+                "also", "plus", "what's more", "on top of that",
+                "and", "additionally", "besides", "another thing"
+            ],
+            r'\bmoreover\b': [
+                "also", "plus", "and", "what's more",
+                "on top of that", "besides", "another thing"
+            ],
+            r'\bhowever\b': [
+                "but", "though", "yet", "still", "although",
+                "on the flip side", "that said", "even so"
+            ],
+            r'\btherefore\b': [
+                "so", "that's why", "which means", "as a result",
+                "this means", "hence", "because of this"
+            ],
+            r'\bconsequently\b': [
+                "so", "as a result", "that's why", "this means",
+                "because of this", "hence", "due to this"
+            ],
+            r'\bsignificant(?:ly)?\b': [
+                "big", "major", "important", "huge", "substantial",
+                "considerable", "notable", "really", "pretty"
+            ],
+            r'\bnumerous\b': [
+                "many", "lots of", "plenty of", "tons of",
+                "countless", "several", "a bunch of"
+            ],
+            r'\butilize\b': [
+                "use", "make use of", "work with", "employ",
+                "take advantage of", "go with"
+            ],
+            r'\bdemonstrate\b': [
+                "show", "prove", "make clear", "illustrate",
+                "reveal", "display", "point out"
+            ],
+            r'\bfacilitate\b': [
+                "help", "make easier", "enable", "assist",
+                "make possible", "support", "help with"
+            ],
+            r'\bimplement\b': [
+                "put in place", "set up", "start using", "apply",
+                "carry out", "execute", "roll out"
+            ],
+            r'\bvarious\b': [
+                "different", "several", "many", "a bunch of",
+                "multiple", "all sorts of"
+            ],
+            r'\bsubstantial\b': [
+                "big", "major", "significant", "large",
+                "considerable", "huge", "pretty big"
+            ]
         }
         
-        self.contraction_map = {
-            'it is': 'it\'s', 'that is': 'that\'s', 'there is': 'there\'s',
-            'we are': 'we\'re', 'they are': 'they\'re', 'you are': 'you\'re',
-            'i am': 'I\'m', 'he is': 'he\'s', 'she is': 'she\'s',
-            'will not': 'won\'t', 'cannot': 'can\'t', 'do not': 'don\'t',
-            'does not': 'doesn\'t', 'did not': 'didn\'t', 'have not': 'haven\'t',
-            'has not': 'hasn\'t', 'had not': 'hadn\'t', 'would not': 'wouldn\'t',
-            'should not': 'shouldn\'t', 'could not': 'couldn\'t'
+        # Contractions for natural speech
+        self.contractions = {
+            r'\bit is\b': "it's",
+            r'\bthat is\b': "that's",
+            r'\bwhat is\b': "what's",
+            r'\bwhere is\b': "where's",
+            r'\bwho is\b': "who's",
+            r'\bwe are\b': "we're",
+            r'\bthey are\b': "they'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'\bwill not\b': "won't",
+            r'\bcannot\b': "can't",
+            r'\bdo not\b': "don't",
+            r'\bdoes not\b': "doesn't",
+            r'\bdid not\b': "didn't",
+            r'\bhave not\b': "haven't",
+            r'\bhas not\b': "hasn't",
+            r'\bhad not\b': "hadn't",
+            r'\bwould not\b': "wouldn't",
+            r'\bshould not\b': "shouldn't",
+            r'\bcould not\b': "couldn'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"
         }
+        
+        # Filler words and phrases humans use
+        self.human_fillers = [
+            'actually', 'basically', 'really', 'pretty much', 'kind of',
+            'sort of', 'you know', 'I mean', 'like', 'well',
+            'honestly', 'frankly', 'obviously', 'clearly'
+        ]
+        
+        # Opinion markers to make text more personal
+        self.opinion_markers = [
+            "I think", "I believe", "In my opinion", "From what I've seen",
+            "It seems to me", "I feel like", "My take is", "Personally,",
+            "From my experience", "I'd say", "I reckon", "I suspect"
+        ]
+        
+        # Casual sentence starters
+        self.casual_starters = [
+            "Look,", "Listen,", "Here's the thing:", "The way I see it,",
+            "To be honest,", "Frankly,", "Let me tell you,", "You know what?",
+            "The truth is,", "Here's what I think:"
+        ]
 
-    def add_human_errors(self, text):
-        """Add subtle human-like imperfections"""
+    def replace_ai_phrases(self, text):
+        """Replace AI-typical phrases with human alternatives"""
+        for pattern, replacements in self.ai_replacements.items():
+            matches = re.finditer(pattern, text, re.IGNORECASE)
+            for match in reversed(list(matches)):  # Reverse to maintain positions
+                replacement = random.choice(replacements)
+                start, end = match.span()
+                # Preserve original capitalization
+                if text[start].isupper():
+                    replacement = replacement.capitalize()
+                text = text[:start] + replacement + text[end:]
+        return text
+
+    def add_contractions(self, text):
+        """Add contractions for natural speech"""
+        for pattern, contraction in self.contractions.items():
+            text = re.sub(pattern, contraction, text, flags=re.IGNORECASE)
+        return text
+
+    def add_personal_touches(self, text):
+        """Add personal opinions and touches"""
         sentences = sent_tokenize(text)
-        humanized_sentences = []
+        if len(sentences) == 0:
+            return text
+            
+        modified_sentences = []
         
-        for sentence in sentences:
-            # Occasionally add filler words
-            if random.random() < 0.3:
-                fillers = ['actually', 'basically', 'really', 'pretty much', 'kind of', 'sort of']
-                filler = random.choice(fillers)
-                words = sentence.split()
-                if len(words) > 3:
-                    insert_pos = random.randint(1, min(3, len(words)-1))
-                    words.insert(insert_pos, filler)
-                    sentence = ' '.join(words)
+        for i, sentence in enumerate(sentences):
+            # Add opinion markers occasionally
+            if random.random() < 0.3 and len(sentence.split()) > 5:
+                opinion = random.choice(self.opinion_markers)
+                sentence = opinion + " " + sentence.lower()
             
-            # Occasionally use more casual phrasing
-            if random.random() < 0.2:
-                sentence = sentence.replace(' and ', ' & ')
+            # Add casual starters occasionally to first sentence
+            elif random.random() < 0.2 and i == 0:
+                starter = random.choice(self.casual_starters)
+                sentence = starter + " " + sentence.lower()
             
-            humanized_sentences.append(sentence)
+            modified_sentences.append(sentence)
         
-        return ' '.join(humanized_sentences)
+        return ' '.join(modified_sentences)
 
-    def vary_sentence_structure(self, text):
-        """Vary sentence structures to appear more human"""
+    def add_natural_fillers(self, text):
+        """Add natural filler words and hesitation"""
         sentences = sent_tokenize(text)
-        varied_sentences = []
+        modified_sentences = []
         
-        for i, sentence in enumerate(sentences):
-            # Randomly combine short sentences
-            if i < len(sentences) - 1 and len(sentence.split()) < 8 and len(sentences[i+1].split()) < 8:
-                if random.random() < 0.4:
-                    connectors = [' and ', ', ', ' - ', ' but ']
-                    connector = random.choice(connectors)
-                    combined = sentence.rstrip('.') + connector + sentences[i+1].lower()
-                    varied_sentences.append(combined)
-                    sentences[i+1] = ""  # Skip next sentence
-                    continue
+        for sentence in sentences:
+            words = sentence.split()
+            
+            # Add fillers occasionally
+            if len(words) > 6 and random.random() < 0.3:
+                filler = random.choice(self.human_fillers)
+                insert_position = random.randint(1, min(4, len(words) - 1))
+                words.insert(insert_position, filler)
             
-            if sentence:  # Only add non-empty sentences
-                varied_sentences.append(sentence)
+            modified_sentences.append(' '.join(words))
         
-        return ' '.join(varied_sentences)
+        return ' '.join(modified_sentences)
 
-    def replace_formal_words(self, text):
-        """Replace formal words with casual alternatives"""
-        for formal, casual_options in self.human_replacements.items():
-            if formal in text.lower():
-                replacement = random.choice(casual_options)
-                text = re.sub(r'\b' + re.escape(formal) + r'\b', replacement, text, flags=re.IGNORECASE)
+    def vary_sentence_structure(self, text):
+        """Vary sentence structures for natural flow"""
+        sentences = sent_tokenize(text)
+        if len(sentences) < 2:
+            return text
+            
+        modified_sentences = []
+        skip_next = False
         
-        return text
-
-    def add_contractions(self, text):
-        """Add contractions to make text more conversational"""
-        for full_form, contraction in self.contraction_map.items():
-            text = re.sub(r'\b' + re.escape(full_form) + r'\b', contraction, text, flags=re.IGNORECASE)
+        for i, sentence in enumerate(sentences):
+            if skip_next:
+                skip_next = False
+                continue
+            
+            # Combine short sentences occasionally
+            if (i < len(sentences) - 1 and 
+                len(sentence.split()) < 8 and 
+                len(sentences[i + 1].split()) < 8 and
+                random.random() < 0.4):
+                
+                connectors = [' and ', ', ', ' - ', ' but ', ' so ']
+                connector = random.choice(connectors)
+                combined = sentence.rstrip('.!?') + connector + sentences[i + 1].lower()
+                modified_sentences.append(combined)
+                skip_next = True
+            else:
+                modified_sentences.append(sentence)
         
-        return text
+        return ' '.join(modified_sentences)
 
-    def adjust_punctuation(self, text):
-        """Adjust punctuation for more natural flow"""
-        # Replace some periods with commas for flow
+    def add_casual_punctuation(self, text):
+        """Add more casual and varied punctuation"""
         sentences = sent_tokenize(text)
-        if len(sentences) > 2:
-            # Occasionally use semicolons
-            if random.random() < 0.3:
-                idx = random.randint(0, len(sentences)-2)
-                if len(sentences[idx].split()) > 6:
-                    sentences[idx] = sentences[idx].rstrip('.') + ';'
-                    sentences[idx+1] = sentences[idx+1][0].lower() + sentences[idx+1][1:]
-        
-        return ' '.join(sentences)
-
-    def add_personal_touches(self, text):
-        """Add personal touches and opinions"""
-        personal_phrases = [
-            "I think", "In my opinion", "From what I've seen", "Personally,",
-            "I believe", "It seems to me", "From my experience"
-        ]
+        modified_sentences = []
         
-        sentences = sent_tokenize(text)
-        if len(sentences) > 1 and random.random() < 0.4:
-            # Add personal phrase to a random sentence
-            idx = random.randint(0, len(sentences)-1)
-            personal_phrase = random.choice(personal_phrases)
-            sentences[idx] = personal_phrase + " " + sentences[idx].lower()
+        for i, sentence in enumerate(sentences):
+            # Sometimes use ellipsis for trailing thoughts
+            if random.random() < 0.1 and i == len(sentences) - 1:
+                sentence = sentence.rstrip('.!?') + '...'
+            
+            # Sometimes use exclamation for emphasis
+            elif random.random() < 0.15:
+                emphasis_words = ['amazing', 'incredible', 'fantastic', 'great', 'awesome', 'really', 'very']
+                if any(word in sentence.lower() for word in emphasis_words):
+                    sentence = sentence.rstrip('.') + '!'
+            
+            modified_sentences.append(sentence)
         
-        return ' '.join(sentences)
+        return ' '.join(modified_sentences)
 
-    def paraphrase_with_synonyms(self, text):
-        """Replace words with synonyms"""
-        words = word_tokenize(text)
-        new_words = []
+    def clean_text(self, text):
+        """Clean up formatting issues"""
+        # Fix multiple spaces
+        text = re.sub(r'\s+', ' ', text)
         
-        for word in words:
-            lower_word = word.lower()
-            if lower_word in self.synonyms and random.random() < 0.3:
-                synonym = random.choice(self.synonyms[lower_word])
-                new_words.append(synonym)
-            else:
-                new_words.append(word)
+        # Fix punctuation spacing
+        text = re.sub(r'\s+([.!?])', r'\1', text)
+        text = re.sub(r'([.!?])\s*([A-Z])', r'\1 \2', text)
         
-        return ' '.join(new_words)
-
-    def humanize_text(self, text, intensity="medium"):
-        """Main humanization function"""
-        if not text or not text.strip():
-            return "Please provide text to humanize."
+        # Ensure proper capitalization after periods
+        def capitalize_after_period(match):
+            return match.group(1) + ' ' + match.group(2).upper()
         
-        # Clean input
-        text = text.strip()
+        text = re.sub(r'([.!?])\s+([a-z])', capitalize_after_period, text)
         
-        # Apply humanization techniques based on intensity
-        if intensity == "light":
-            text = self.add_contractions(text)
-            text = self.replace_formal_words(text)
-        elif intensity == "medium":
-            text = self.replace_formal_words(text)
-            text = self.add_contractions(text)
-            text = self.paraphrase_with_synonyms(text)
-            text = self.vary_sentence_structure(text)
-        else:  # heavy
-            text = self.replace_formal_words(text)
-            text = self.add_contractions(text)
-            text = self.paraphrase_with_synonyms(text)
-            text = self.vary_sentence_structure(text)
-            text = self.add_human_errors(text)
-            text = self.adjust_punctuation(text)
-            text = self.add_personal_touches(text)
-        
-        return text
+        return text.strip()
 
     def get_readability_score(self, text):
         """Calculate readability metrics"""
@@ -242,71 +294,123 @@ class AIContentHumanizer:
                 level = "Very Difficult"
             
             return f"Flesch Score: {flesch_score:.1f} ({level})\nGrade Level: {fk_grade:.1f}"
-        except:
-            return "Could not calculate readability"
+        except Exception as e:
+            return f"Could not calculate readability: {str(e)}"
+
+    def humanize_text(self, text, intensity="medium"):
+        """Main humanization function"""
+        if not text or not text.strip():
+            return "Please provide text to humanize."
+        
+        try:
+            # Clean input
+            text = text.strip()
+            
+            # Apply humanization techniques based on intensity
+            text = self.replace_ai_phrases(text)
+            text = self.add_contractions(text)
+            
+            if intensity in ["medium", "heavy"]:
+                text = self.vary_sentence_structure(text)
+                text = self.add_personal_touches(text)
+                text = self.add_casual_punctuation(text)
+            
+            if intensity == "heavy":
+                text = self.add_natural_fillers(text)
+            
+            # Final cleanup
+            text = self.clean_text(text)
+            
+            return text
+            
+        except Exception as e:
+            return f"Error processing text: {str(e)}\n\nOriginal text: {text}"
 
 def create_interface():
     humanizer = AIContentHumanizer()
     
     def process_text(input_text, intensity):
         if not input_text:
-            return "Please enter some text to humanize.", ""
-        
-        humanized = humanizer.humanize_text(input_text, intensity)
-        readability = humanizer.get_readability_score(humanized)
+            return "Please enter some text to humanize.", "No text provided for analysis."
         
-        return humanized, readability
+        try:
+            humanized = humanizer.humanize_text(input_text, intensity)
+            readability = humanizer.get_readability_score(humanized)
+            return humanized, readability
+        except Exception as e:
+            return f"Error: {str(e)}", "Error in processing"
     
     # Custom CSS for better UI
     css = """
     .gradio-container {
         font-family: 'Inter', sans-serif;
+        max-width: 1200px;
+        margin: 0 auto;
     }
     .main-header {
         text-align: center;
         margin-bottom: 30px;
+        padding: 20px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 15px;
+        color: white;
     }
     .feature-box {
         border: 1px solid #e1e5e9;
-        border-radius: 8px;
+        border-radius: 12px;
+        padding: 20px;
+        margin: 15px 0;
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    }
+    .example-box {
+        background: #f8f9fa;
+        border-left: 4px solid #007bff;
         padding: 15px;
         margin: 10px 0;
-        background: #f8f9fa;
+        border-radius: 5px;
     }
     """
     
-    with gr.Blocks(css=css, title="AI Content Humanizer") as interface:
+    with gr.Blocks(css=css, title="AI Content Humanizer", theme=gr.themes.Soft()) as interface:
         gr.HTML("""
         <div class="main-header">
             <h1>🤖➡️👤 AI Content Humanizer</h1>
-            <p>Transform AI-generated content into natural, human-like text</p>
+            <p style="font-size: 18px; margin-top: 10px;">Transform AI-generated content into natural, human-like text</p>
+            <p style="font-size: 14px; opacity: 0.9;">Make your content sound more conversational and authentic</p>
         </div>
         """)
         
         with gr.Row():
-            with gr.Column(scale=2):
+            with gr.Column(scale=1):
                 input_text = gr.Textbox(
                     label="📝 Enter AI-generated text",
-                    placeholder="Paste your AI-generated content here...",
-                    lines=10,
-                    max_lines=20
+                    placeholder="Paste your AI-generated content here...\n\nExample: 'It is important to note that artificial intelligence has numerous applications in various industries. Furthermore, these technologies can significantly enhance productivity.'",
+                    lines=12,
+                    max_lines=25
                 )
                 
-                intensity = gr.Radio(
-                    choices=["light", "medium", "heavy"],
-                    value="medium",
-                    label="🎛️ Humanization Intensity",
-                    info="Light: Basic changes | Medium: Moderate restructuring | Heavy: Extensive humanization"
-                )
+                with gr.Row():
+                    intensity = gr.Radio(
+                        choices=["light", "medium", "heavy"],
+                        value="medium",
+                        label="🎛️ Humanization Level",
+                        info="Choose how much to humanize the text"
+                    )
                 
-                humanize_btn = gr.Button("✨ Humanize Text", variant="primary", size="lg")
+                humanize_btn = gr.Button(
+                    "✨ Humanize Text", 
+                    variant="primary", 
+                    size="lg",
+                    scale=1
+                )
             
-            with gr.Column(scale=2):
+            with gr.Column(scale=1):
                 output_text = gr.Textbox(
                     label="✅ Humanized Text",
-                    lines=10,
-                    max_lines=20,
-                    interactive=False
+                    lines=12,
+                    max_lines=25,
+                    interactive=True,
+                    show_copy_button=True
                 )
                 
                 readability_info = gr.Textbox(
@@ -315,33 +419,68 @@ def create_interface():
                     interactive=False
                 )
         
-        gr.HTML("""
-        <div class="feature-box">
-            <h3>🎯 Features:</h3>
-            <ul>
-                <li><strong>Smart Paraphrasing:</strong> Replaces formal AI language with natural expressions</li>
-                <li><strong>Sentence Restructuring:</strong> Varies sentence patterns for human-like flow</li>
-                <li><strong>Casual Contractions:</strong> Adds natural contractions and informal language</li>
-                <li><strong>Personal Touch:</strong> Incorporates personal opinions and experiences</li>
-                <li><strong>Readability Analysis:</strong> Provides readability scores and grade levels</li>
-            </ul>
-        </div>
-        """)
+        # Information sections
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("""
+                <div class="feature-box">
+                    <h3>🎯 Humanization Features:</h3>
+                    <ul style="text-align: left;">
+                        <li><strong>🔄 Smart Phrase Replacement:</strong> Replaces robotic AI phrases with natural expressions</li>
+                        <li><strong>💬 Conversational Tone:</strong> Adds contractions and casual language</li>
+                        <li><strong>🎭 Personal Touch:</strong> Incorporates opinions and personal perspectives</li>
+                        <li><strong>📝 Natural Flow:</strong> Varies sentence structure and adds fillers</li>
+                        <li><strong>📊 Readability Analysis:</strong> Provides reading level assessment</li>
+                    </ul>
+                </div>
+                """)
+        
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("""
+                <div class="example-box">
+                    <h4>💡 Intensity Levels:</h4>
+                    <p><strong>Light:</strong> Basic phrase replacement and contractions</p>
+                    <p><strong>Medium:</strong> + Personal opinions and sentence restructuring</p>
+                    <p><strong>Heavy:</strong> + Filler words and extensive casual modifications</p>
+                </div>
+                """)
         
         # Example texts
         examples = [
-            ["Artificial intelligence has numerous applications in various industries. It is important to note that AI can significantly enhance productivity and efficiency. Furthermore, machine learning algorithms can process vast amounts of data to generate valuable insights.", "medium"],
-            ["The implementation of sustainable practices is crucial for environmental conservation. Organizations must utilize innovative technologies to facilitate eco-friendly operations. Moreover, it is essential to demonstrate commitment to reducing carbon footprint.", "heavy"],
-            ["In conclusion, the research demonstrates that renewable energy sources are becoming increasingly viable. Therefore, governments should implement policies that promote clean energy adoption. It is worth noting that this transition requires substantial investment.", "light"]
+            [
+                "It is important to note that artificial intelligence has numerous applications in various industries. Furthermore, machine learning algorithms can demonstrate significant improvements in efficiency. Therefore, organizations should utilize these technologies to facilitate better outcomes.",
+                "medium"
+            ],
+            [
+                "In conclusion, the implementation of sustainable practices is crucial for environmental conservation. Moreover, it should be noted that organizations must demonstrate commitment to reducing their carbon footprint. Consequently, various strategies should be utilized to achieve these objectives.",
+                "heavy"
+            ],
+            [
+                "The research demonstrates that renewable energy sources are becoming increasingly viable. However, it is important to note that substantial investment is required. Therefore, governments should implement policies that facilitate the adoption of clean energy technologies.",
+                "light"
+            ]
         ]
         
         gr.Examples(
             examples=examples,
             inputs=[input_text, intensity],
-            label="📚 Try these examples:"
+            outputs=[output_text, readability_info],
+            fn=process_text,
+            cache_examples=True,
+            label="📚 Try these examples (click to load):"
         )
         
+        # Event handlers
         humanize_btn.click(
+            fn=process_text,
+            inputs=[input_text, intensity],
+            outputs=[output_text, readability_info],
+            show_progress=True
+        )
+        
+        # Allow Enter key to trigger humanization
+        input_text.submit(
             fn=process_text,
             inputs=[input_text, intensity],
             outputs=[output_text, readability_info]
@@ -350,5 +489,10 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
+    print("Starting AI Content Humanizer...")
     interface = create_interface()
-    interface.launch()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )