Update app.py

app.py

@@ -1,16 +1,20 @@
+import os
 import gradio as gr
 import random
 import re
 import nltk
 from nltk.tokenize import sent_tokenize, word_tokenize
-import string
 from textstat import flesch_reading_ease, flesch_kincaid_grade
 
+# Setup NLTK download path
+os.environ['NLTK_DATA'] = '/tmp/nltk_data'
+
 # Download required NLTK data
 try:
-    nltk.download('punkt', quiet=True)
-    nltk.download('averaged_perceptron_tagger', quiet=True)
-    nltk.download('stopwords', quiet=True)
+    nltk.download('punkt', download_dir='/tmp/nltk_data')
+    nltk.download('averaged_perceptron_tagger', download_dir='/tmp/nltk_data')
+    nltk.download('stopwords', download_dir='/tmp/nltk_data')
+    nltk.data.path.append('/tmp/nltk_data')
     print("NLTK data downloaded successfully")
 except Exception as e:
     print(f"NLTK download error: {e}")
@@ -18,89 +22,30 @@ except Exception as e:
 class AIContentHumanizer:
     def __init__(self):
         self.setup_humanization_patterns()
-        
+
     def setup_humanization_patterns(self):
-        """Setup patterns for humanizing text"""
-        
-        # 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"
-            ]
+            r'\bit is important to note that\b': ["worth mentioning that", "keep in mind that", "note that"],
+            r'\bit should be noted that\b': ["remember that", "worth noting that", "keep in mind"],
+            r'\bin conclusion\b': ["to wrap up", "all in all", "bottom line"],
+            r'\bto conclude\b': ["to wrap up", "all in all", "in the end"],
+            r'\bfurthermore\b': ["also", "plus", "what's more"],
+            r'\bmoreover\b': ["also", "plus", "and"],
+            r'\bhowever\b': ["but", "though", "yet"],
+            r'\btherefore\b': ["so", "that's why", "which means"],
+            r'\bconsequently\b': ["so", "as a result", "that's why"],
+            r'\bsignificant(?:ly)?\b': ["big", "major", "important"],
+            r'\bnumerous\b': ["many", "lots of", "plenty of"],
+            r'\butilize\b': ["use", "make use of", "work with"],
+            r'\bdemonstrate\b': ["show", "prove", "make clear"],
+            r'\bfacilitate\b': ["help", "make easier", "enable"],
+            r'\bimplement\b': ["put in place", "set up", "start using"],
+            r'\bvarious\b': ["different", "several", "many"],
+            r'\bsubstantial\b': ["big", "major", "significant"]
         }
-        
-        # 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",
@@ -123,376 +68,132 @@ class AIContentHumanizer:
             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:"
-        ]
+        self.human_fillers = ['actually', 'basically', 'really', 'pretty much']
+        self.opinion_markers = ["I think", "I believe", "In my opinion"]
+        self.casual_starters = ["Look,", "Listen,", "Here's the thing:"]
 
     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
+            for match in reversed(list(matches)):
                 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)
-        if len(sentences) == 0:
-            return text
-            
-        modified_sentences = []
-        
-        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()
-            
-            # 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()
-            
-            modified_sentences.append(sentence)
-        
-        return ' '.join(modified_sentences)
+        modified = []
+        for i, s in enumerate(sentences):
+            if random.random() < 0.3:
+                s = random.choice(self.opinion_markers) + " " + s.lower()
+            elif i == 0 and random.random() < 0.2:
+                s = random.choice(self.casual_starters) + " " + s.lower()
+            modified.append(s)
+        return ' '.join(modified)
 
     def add_natural_fillers(self, text):
-        """Add natural filler words and hesitation"""
         sentences = sent_tokenize(text)
-        modified_sentences = []
-        
-        for sentence in sentences:
-            words = sentence.split()
-            
-            # Add fillers occasionally
+        modified = []
+        for s in sentences:
+            words = s.split()
             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)
-            
-            modified_sentences.append(' '.join(words))
-        
-        return ' '.join(modified_sentences)
+                words.insert(random.randint(1, min(4, len(words)-1)), random.choice(self.human_fillers))
+            modified.append(' '.join(words))
+        return ' '.join(modified)
 
     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
-        
-        for i, sentence in enumerate(sentences):
-            if skip_next:
-                skip_next = False
+        modified, skip = [], False
+        for i in range(len(sentences)):
+            if skip:
+                skip = 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
+            if i < len(sentences)-1 and len(sentences[i].split()) < 8 and len(sentences[i+1].split()) < 8 and random.random() < 0.4:
+                combined = sentences[i].rstrip('.!?') + ', ' + sentences[i+1].lower()
+                modified.append(combined)
+                skip = True
             else:
-                modified_sentences.append(sentence)
-        
-        return ' '.join(modified_sentences)
+                modified.append(sentences[i])
+        return ' '.join(modified)
 
     def add_casual_punctuation(self, text):
-        """Add more casual and varied punctuation"""
         sentences = sent_tokenize(text)
-        modified_sentences = []
-        
-        for i, sentence in enumerate(sentences):
-            # Sometimes use ellipsis for trailing thoughts
+        modified = []
+        for i, s in enumerate(sentences):
             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(modified_sentences)
+                s = s.rstrip('.!?') + '...'
+            elif random.random() < 0.15 and any(word in s.lower() for word in ['amazing', 'incredible']):
+                s = s.rstrip('.') + '!'
+            modified.append(s)
+        return ' '.join(modified)
 
     def clean_text(self, text):
-        """Clean up formatting issues"""
-        # Fix multiple spaces
         text = re.sub(r'\s+', ' ', text)
-        
-        # Fix punctuation spacing
         text = re.sub(r'\s+([.!?])', r'\1', text)
         text = re.sub(r'([.!?])\s*([A-Z])', r'\1 \2', text)
-        
-        # Ensure proper capitalization after periods
-        def capitalize_after_period(match):
-            return match.group(1) + ' ' + match.group(2).upper()
-        
-        text = re.sub(r'([.!?])\s+([a-z])', capitalize_after_period, text)
-        
+        def cap(match): return match.group(1) + ' ' + match.group(2).upper()
+        text = re.sub(r'([.!?])\s+([a-z])', cap, text)
         return text.strip()
 
     def get_readability_score(self, text):
-        """Calculate readability metrics"""
         try:
-            flesch_score = flesch_reading_ease(text)
-            fk_grade = flesch_kincaid_grade(text)
-            
-            if flesch_score >= 90:
-                level = "Very Easy"
-            elif flesch_score >= 80:
-                level = "Easy"
-            elif flesch_score >= 70:
-                level = "Fairly Easy"
-            elif flesch_score >= 60:
-                level = "Standard"
-            elif flesch_score >= 50:
-                level = "Fairly Difficult"
-            elif flesch_score >= 30:
-                level = "Difficult"
-            else:
-                level = "Very Difficult"
-            
-            return f"Flesch Score: {flesch_score:.1f} ({level})\nGrade Level: {fk_grade:.1f}"
+            score = flesch_reading_ease(text)
+            grade = flesch_kincaid_grade(text)
+            level = ("Very Easy" if score >= 90 else "Easy" if score >= 80 else "Fairly Easy" if score >= 70 else "Standard" if score >= 60 else "Fairly Difficult" if score >= 50 else "Difficult" if score >= 30 else "Very Difficult")
+            return f"Flesch Score: {score:.1f} ({level})\nGrade Level: {grade:.1f}"
         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
-            
+            return self.clean_text(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.", "No text provided for analysis."
-        
+            return "Please enter some text to humanize.", "No text provided."
         try:
-            humanized = humanizer.humanize_text(input_text, intensity)
-            readability = humanizer.get_readability_score(humanized)
-            return humanized, readability
+            result = humanizer.humanize_text(input_text, intensity)
+            score = humanizer.get_readability_score(result)
+            return result, score
         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: 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;
-        border-radius: 5px;
-    }
-    """
-    
-    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 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=1):
-                input_text = gr.Textbox(
-                    label="📝 Enter AI-generated text",
-                    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
-                )
-                
-                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",
-                    scale=1
-                )
-            
-            with gr.Column(scale=1):
-                output_text = gr.Textbox(
-                    label="✅ Humanized Text",
-                    lines=12,
-                    max_lines=25,
-                    interactive=True,
-                    show_copy_button=True
-                )
-                
-                readability_info = gr.Textbox(
-                    label="📊 Readability Analysis",
-                    lines=3,
-                    interactive=False
-                )
-        
-        # 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 = [
-            [
-                "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],
-            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]
-        )
-    
+            return f"Error: {str(e)}", "Processing error"
+
+    with gr.Blocks(title="AI Content Humanizer") as interface:
+        gr.Markdown("""# 🤖➡️👤 AI Content Humanizer
+Transform AI-generated content into human-sounding, casual, and readable text!""")
+        input_text = gr.Textbox(label="AI-generated Text", lines=8)
+        intensity = gr.Radio(["light", "medium", "heavy"], value="medium", label="Humanization Level")
+        output_text = gr.Textbox(label="Humanized Text", lines=8, show_copy_button=True)
+        readability = gr.Textbox(label="Readability Score", lines=2)
+        btn = gr.Button("Humanize Text")
+        btn.click(fn=process_text, inputs=[input_text, intensity], outputs=[output_text, readability])
+        input_text.submit(fn=process_text, inputs=[input_text, intensity], outputs=[output_text, readability])
     return interface
 
 if __name__ == "__main__":
     print("Starting AI Content Humanizer...")
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
+    app = create_interface()
+    app.launch(server_name="0.0.0.0", server_port=7860, show_error=True)