Update app.py

app.py

@@ -1,24 +1,231 @@
 import gradio as gr
-from humanize import humanize_text, translate_text
-
-TONE_PROMPTS = [...]  # Same as your existing config
-
-def process_text(text, tone, lang):
-    humanized = humanize_text(text, tone)
-    if lang != "None":
-        lang_code = re.search(r"\((.*?)\)", lang).group(1).lower()  # Extract "da" from "da (Danish)"
-        humanized = translate_text(humanized, lang_code)
-    return humanized
-
-gr.Interface(
-    fn=process_text,
-    inputs=[
-        gr.Textbox(label="Input Text", placeholder="Paste AI-generated text here..."),
-        gr.Dropdown(list(TONE_PROPS.keys()), label="Tone", value="General"),
-        gr.Dropdown(["None", "da (Danish)", "no (Norwegian)", ...], label="Translate to")
-    ],
-    outputs=gr.Textbox(label="Humanized Output"),
-    allow_flagging="never",
-    title="VoxAI Pro 🚀",
-    description="Transform AI text into undetectable human-like content"
-).launch()
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+import torch
+from translatepy import Translator
+import logging
+from typing import Dict, Optional
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor
+import nltk
+from nltk.tokenize import sent_tokenize
+nltk.download('punkt')
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class TextHumanizer:
+    def __init__(self):
+        # Initialize AI detection model
+        self.detector = pipeline(
+            "text-classification",
+            model="roberta-base-openai-detector",
+            device=0 if torch.cuda.is_available() else -1
+        )
+        
+        # Initialize text generation model
+        self.humanizer = pipeline(
+            "text2text-generation",
+            model="facebook/bart-large-cnn",
+            device=0 if torch.cuda.is_available() else -1
+        )
+        
+        # Initialize translator
+        self.translator = Translator()
+        
+        # Enhanced tone prompts with more natural variations
+        self.tone_prompts = {
+            "Casual": [
+                "Rewrite this in a laid-back, conversational style with some personality: {text}",
+                "Make this sound more casual and friendly, like you're chatting with a buddy: {text}",
+                "Rephrase this in a relaxed way, adding some humor where it fits: {text}"
+            ],
+            "Business": [
+                "Transform this into clear, professional business language: {text}",
+                "Rewrite this for a corporate audience, maintaining professionalism: {text}",
+                "Convert this into business-appropriate language with precise terminology: {text}"
+            ],
+            "Academic": [
+                "Rephrase this using scholarly language and academic conventions: {text}",
+                "Rewrite this for an academic paper, with proper technical terminology: {text}",
+                "Transform this into academic prose with appropriate formal language: {text}"
+            ],
+            "Creative": [
+                "Rewrite this with vivid imagery and engaging metaphors: {text}",
+                "Transform this using creative language and sensory details: {text}",
+                "Rephrase this with artistic flair and descriptive language: {text}"
+            ],
+            "Email": [
+                "Convert this into a professional email while maintaining warmth: {text}",
+                "Rewrite this as a clear, concise email with appropriate tone: {text}",
+                "Transform this into email format with professional courtesy: {text}"
+            ]
+        }
+
+    def detect_ai_text(self, text: str) -> float:
+        """
+        Detect if text is AI-generated and return confidence score
+        """
+        try:
+            # Split long text into sentences and analyze each chunk
+            sentences = sent_tokenize(text)
+            chunks = [' '.join(sentences[i:i+5]) for i in range(0, len(sentences), 5)]
+            
+            scores = []
+            for chunk in chunks:
+                result = self.detector(chunk)[0]
+                if result['label'] == 'ARTIFICIAL':
+                    scores.append(result['score'])
+            
+            return max(scores) if scores else 0.0
+            
+        except Exception as e:
+            logger.error(f"Error in AI detection: {str(e)}")
+            return 0.0
+
+    def add_human_variations(self, text: str) -> str:
+        """
+        Add human-like variations to text
+        """
+        # Add occasional filler words
+        fillers = ["well", "you know", "actually", "basically", "I mean"]
+        sentences = sent_tokenize(text)
+        
+        for i in range(len(sentences)):
+            if random.random() < 0.3:  # 30% chance to add filler
+                filler = random.choice(fillers)
+                sentences[i] = f"{filler}, {sentences[i].lower()}"
+        
+        # Add minor grammatical variations
+        text = ' '.join(sentences)
+        text = text.replace(" can not ", " can't ")
+        text = text.replace(" do not ", " don't ")
+        
+        return text
+
+    def humanize_text(
+        self,
+        text: str,
+        tone: str,
+        translate_to: Optional[str] = None,
+        max_retries: int = 3
+    ) -> str:
+        """
+        Main function to humanize text with error handling and retries
+        """
+        try:
+            # Check if text is likely AI-generated
+            ai_score = self.detect_ai_text(text)
+            logger.info(f"AI detection score: {ai_score}")
+            
+            if ai_score < 0.7:  # If text already seems human-like
+                logger.info("Text appears human-written, making minor adjustments")
+                output = self.add_human_variations(text)
+            else:
+                # Select random prompt variation for the chosen tone
+                prompt = random.choice(self.tone_prompts[tone]).format(text=text)
+                
+                # Try generation with retries
+                for attempt in range(max_retries):
+                    try:
+                        output = self.humanizer(
+                            prompt,
+                            max_length=min(len(text) * 2, 1000),
+                            num_beams=4,
+                            temperature=0.8,
+                            top_p=0.9
+                        )[0]['generated_text']
+                        
+                        # Add human variations
+                        output = self.add_human_variations(output)
+                        
+                        # Verify the output is more human-like
+                        new_ai_score = self.detect_ai_text(output)
+                        if new_ai_score < ai_score:
+                            break
+                        elif attempt < max_retries - 1:
+                            logger.warning(f"Attempt {attempt + 1}: Output still seems AI-like, retrying...")
+                            time.sleep(1)
+                    except Exception as e:
+                        if attempt < max_retries - 1:
+                            logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+                            time.sleep(1)
+                        else:
+                            raise
+            
+            # Handle translation if requested
+            if translate_to and translate_to != "None":
+                lang_code = translate_to.split(" ")[0]
+                output = self.translator.translate(output, destination_language=lang_code).result
+            
+            return output
+
+        except Exception as e:
+            logger.error(f"Error in humanization process: {str(e)}")
+            return f"Error processing text: {str(e)}"
+
+# Initialize Gradio interface with improved UI
+def create_interface():
+    humanizer = TextHumanizer()
+    
+    def process_text(text: str, tone: str, translate_to: str) -> str:
+        return humanizer.humanize_text(text, tone, translate_to)
+    
+    iface = gr.Interface(
+        fn=process_text,
+        inputs=[
+            gr.Textbox(
+                label="Input Text",
+                placeholder="Paste your AI-generated text here...",
+                lines=5
+            ),
+            gr.Dropdown(
+                choices=list(humanizer.tone_prompts.keys()),
+                label="Writing Style",
+                value="Casual",
+                info="Select the desired writing style for the output"
+            ),
+            gr.Dropdown(
+                choices=[
+                    "None",
+                    "da (Danish)",
+                    "no (Norwegian)",
+                    "sv (Swedish)",
+                    "es (Spanish)",
+                    "fr (French)",
+                    "de (German)"
+                ],
+                label="Translate to",
+                value="None",
+                info="Optional: translate the output to another language"
+            )
+        ],
+        outputs=gr.Textbox(label="Humanized Output", lines=5),
+        title="AI Text Humanizer",
+        description="Convert AI-generated text into more natural, human-like writing",
+        examples=[
+            ["The neural network processes information through multiple layers of interconnected nodes.",
+             "Casual",
+             "None"],
+            ["The implementation of artificial intelligence in healthcare systems has shown promising results.",
+             "Business",
+             "es (Spanish)"]
+        ],
+        cache_examples=True
+    )
+    return iface
+
+if __name__ == "__main__":
+    # Set up thread pool for handling multiple requests
+    with ThreadPoolExecutor(max_workers=4) as executor:
+        interface = create_interface()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            enable_queue=True
+        )