Update app.py

app.py

@@ -77,6 +77,389 @@ def download_dependencies():
 
 download_dependencies()
 
+
+# ---------------------------------------------------------------------------
+# 10-Layer Humanizer — pure Python/NLTK/regex, no external API
+# ---------------------------------------------------------------------------
+
+class LayeredHumanizer:
+    """
+    10 humanization layers using only rule-based NLP (NLTK + regex).
+    No T5, no external API. Produces clean, readable English output.
+    """
+
+    # Layer 1: only replace known AI-sounding phrases — never touch content words
+    AI_PHRASE_MAP = {
+        "leverage": ["use", "apply", "tap into"],
+        "utilize": ["use", "employ", "apply"],
+        "utilise": ["use", "employ", "apply"],
+        "delve into": ["explore", "look into", "examine"],
+        "delve": ["explore", "dig into", "look into"],
+        "furthermore": ["also", "on top of that", "what's more"],
+        "moreover": ["also", "besides", "what's more"],
+        "nevertheless": ["still", "even so", "but"],
+        "consequently": ["so", "as a result", "because of this"],
+        "subsequently": ["then", "after that", "later"],
+        "facilitate": ["help", "enable", "make easier"],
+        "demonstrate": ["show", "prove", "reveal"],
+        "indicate": ["show", "suggest", "point to"],
+        "significant": ["important", "major", "notable"],
+        "substantial": ["large", "considerable", "major"],
+        "comprehensive": ["complete", "thorough", "full"],
+        "fundamental": ["basic", "core", "key"],
+        "innovative": ["new", "creative", "fresh"],
+        "robust": ["strong", "solid", "reliable"],
+        "seamless": ["smooth", "easy", "fluid"],
+        "streamline": ["simplify", "improve", "smooth out"],
+        "optimize": ["improve", "refine", "boost"],
+        "optimise": ["improve", "refine", "boost"],
+        "paradigm": ["model", "approach", "way"],
+        "synergy": ["teamwork", "cooperation", "collaboration"],
+        "meticulous": ["careful", "thorough", "detailed"],
+        "intricate": ["complex", "detailed", "involved"],
+        "myriad": ["many", "numerous", "countless"],
+        "plethora": ["abundance", "wide range", "many"],
+        "in order to": ["to"],
+        "due to the fact that": ["because", "since"],
+        "with regard to": ["about", "regarding"],
+        "in terms of": ["regarding", "when it comes to"],
+        "prior to": ["before"],
+        "subsequent to": ["after", "following"],
+        "in conclusion": ["finally", "to wrap up"],
+        "to summarize": ["in short", "to sum up"],
+        "it is worth noting that": ["notably,", "worth mentioning,"],
+        "one must consider": ["consider", "think about"],
+        "a testament to": ["proof of", "evidence of"],
+        "cutting-edge": ["advanced", "modern", "latest"],
+        "state-of-the-art": ["advanced", "modern", "top-notch"],
+        "implement": ["use", "apply", "put in place"],
+        "obtain": ["get", "gain", "acquire"],
+        "maintain": ["keep", "hold", "sustain"],
+        "establish": ["set up", "create", "build"],
+    }
+
+    # Layer 5: personal words — only ONE per sentence, never stacked
+    PERSONAL_WORDS = [
+        "honestly", "really", "quite", "truly", "actually", "genuinely"
+    ]
+
+    # Layer 6: connectors — inserted between sentences only
+    CONNECTORS = [
+        "And that matters.",
+        "But here's the thing —",
+        "At the same time,",
+        "Which is why",
+        "More than anything,",
+        "And that changes things.",
+        "Think about it —",
+        "That's exactly what happened.",
+    ]
+
+    # Layer 7: casual swaps on specific formal patterns only
+    CASUAL_SWAPS = [
+        (r'\bis very important\b', 'really matters'),
+        (r'\bis significant\b', 'is a big deal'),
+        (r'\bis essential\b', 'is key'),
+        (r'\bIt is clear that\b', 'Clearly,'),
+        (r'\bIt is important to note that\b', 'Worth noting:'),
+        (r'\bOne must consider\b', 'Think about'),
+        (r'\bIt should be noted that\b', 'Note that'),
+        (r'\bno longer just\b', 'more than just'),
+    ]
+
+    def __init__(self):
+        self._stop = None
+
+    def _get_stop_words(self):
+        if self._stop is None:
+            try:
+                self._stop = set(stopwords.words('english'))
+            except Exception:
+                self._stop = set()
+        return self._stop
+
+    # ------------------------------------------------------------------ #
+    #  Layers                                                              #
+    # ------------------------------------------------------------------ #
+
+    def layer1_synonym_replacement(self, text: str) -> str:
+        """Replace AI-sounding phrases only — never touch content/proper nouns."""
+        result = text
+        for phrase, options in sorted(self.AI_PHRASE_MAP.items(), key=lambda x: -len(x[0])):
+            pattern = r'(?<!\w)' + re.escape(phrase) + r'(?!\w)'
+            if re.search(pattern, result, re.IGNORECASE):
+                replacement = random.choice(options)
+                result = re.sub(pattern, replacement, result, flags=re.IGNORECASE, count=1)
+        return result
+
+    def layer2_voice_swap(self, text: str) -> str:
+        """Lightly vary sentence openings on every 4th sentence only."""
+        sentences = sent_tokenize(text)
+        out = []
+        for i, sent in enumerate(sentences):
+            if i % 4 == 0 and len(sent.split()) > 8:
+                m = re.match(
+                    r'^(.+?)\s+(shows?|reveals?|proves?|indicates?)\s+that\s+(.+?)([.!?])$',
+                    sent, re.IGNORECASE
+                )
+                if m:
+                    sent = f"What {m.group(1).lower()} {m.group(2).lower()} is that {m.group(3)}{m.group(4)}"
+            out.append(sent)
+        return " ".join(out)
+
+    def layer3_simplification(self, text: str) -> str:
+        """Strip academic filler phrases cleanly."""
+        fillers = [
+            r'it is worth noting that\s+',
+            r'in light of the aforementioned\s*,?\s*',
+            r'one must consider that\s+',
+            r'it should be noted that\s+',
+            r'it is important to note that\s+',
+            r'needless to say,?\s+',
+            r'as previously mentioned,?\s+',
+            r'for all intents and purposes,?\s+',
+            r'it goes without saying that\s+',
+        ]
+        result = text
+        for f in fillers:
+            result = re.sub(f, '', result, flags=re.IGNORECASE)
+        result = re.sub(r'(?<=[.!?])\s+([a-z])', lambda m: ' ' + m.group(1).upper(), result)
+        return result.strip()
+
+    def layer4_sentence_separation(self, text: str) -> str:
+        """Split only genuinely long sentences (>30 words) at safe split points."""
+        sentences = sent_tokenize(text)
+        out = []
+        split_markers = [', and ', ', but ', ', so ', ', yet ', ', while ']
+        for sent in sentences:
+            words = sent.split()
+            if len(words) > 30:
+                split_done = False
+                for marker in split_markers:
+                    if marker in sent:
+                        idx = sent.index(marker)
+                        first = sent[:idx].strip()
+                        second = sent[idx + len(marker):].strip()
+                        if len(first.split()) >= 6 and len(second.split()) >= 6:
+                            if not first.endswith(('.', '!', '?')):
+                                first += '.'
+                            second = second[0].upper() + second[1:]
+                            out.extend([first, second])
+                            split_done = True
+                            break
+                if not split_done:
+                    out.append(sent)
+            else:
+                out.append(sent)
+        return " ".join(out)
+
+    def layer5_personal_touch(self, text: str) -> str:
+        """Add ONE personal word per eligible sentence — never stack them."""
+        sentences = sent_tokenize(text)
+        out = []
+        personal_starts = set(w.lower() for w in self.PERSONAL_WORDS)
+        for i, sent in enumerate(sentences):
+            first_word = sent.split()[0].lower().rstrip(',') if sent.split() else ''
+            if (i % 4 == 0
+                    and len(sent.split()) > 6
+                    and first_word not in personal_starts):
+                word = random.choice(self.PERSONAL_WORDS)
+                sent = f"{word.capitalize()}, {sent[0].lower() + sent[1:]}"
+            out.append(sent)
+        return " ".join(out)
+
+    def layer6_connective_flow(self, text: str) -> str:
+        """Insert a connector phrase before every 5th sentence only."""
+        sentences = sent_tokenize(text)
+        if len(sentences) < 3:
+            return text
+        out = []
+        for i, sent in enumerate(sentences):
+            if i > 0 and i % 5 == 0:
+                connector = random.choice(self.CONNECTORS)
+                sent = f"{connector} {sent[0].lower() + sent[1:]}"
+            out.append(sent)
+        return " ".join(out)
+
+    def layer7_tonal_variation(self, text: str) -> str:
+        """Apply casual swaps to at most 2 sentences."""
+        sentences = sent_tokenize(text)
+        changed = 0
+        for i, sent in enumerate(sentences):
+            if changed >= 2:
+                break
+            for pattern, replacement in self.CASUAL_SWAPS:
+                new_sent = re.sub(pattern, replacement, sent, flags=re.IGNORECASE)
+                if new_sent != sent:
+                    sentences[i] = new_sent
+                    changed += 1
+                    break
+        return " ".join(sentences)
+
+    def layer8_redundancy_removal(self, text: str) -> str:
+        """Remove a filler word if it appears more than twice, keeping only 2."""
+        fillers = ["basically", "essentially", "actually", "really", "quite", "honestly", "genuinely"]
+        result = text
+        for filler in fillers:
+            pattern = r'\b' + re.escape(filler) + r'\b'
+            matches = re.findall(pattern, result, re.IGNORECASE)
+            if len(matches) > 2:
+                count = [0]
+                def replacer(m, c=count):
+                    c[0] += 1
+                    return m.group(0) if c[0] <= 2 else ''
+                result = re.sub(pattern, replacer, result, flags=re.IGNORECASE)
+        result = re.sub(r'  +', ' ', result)
+        result = re.sub(r'\s+([,.!?;:])', r'\1', result)
+        return result.strip()
+
+    def layer9_safe_synonym_pass(self, text: str) -> str:
+        """Light hand-curated synonym pass on safe adjectives/adverbs only."""
+        safe_map = {
+            "dramatic": ["remarkable", "striking", "major"],
+            "powerful": ["capable", "strong", "impressive"],
+            "popular": ["common", "widely used", "well-known"],
+            "addictive": ["compelling", "engaging", "hard to put down"],
+            "commercially": ["publicly", "widely"],
+            "quietly": ["gradually", "steadily"],
+            "suddenly": ["quickly", "almost overnight"],
+            "virtually": ["practically", "almost"],
+            "genuinely": ["truly", "really"],
+            "dramatically": ["significantly", "sharply", "greatly"],
+        }
+        result = text
+        for word, options in safe_map.items():
+            pattern = r'\b' + re.escape(word) + r'\b'
+            if re.search(pattern, result, re.IGNORECASE) and random.random() < 0.5:
+                result = re.sub(pattern, random.choice(options), result,
+                                flags=re.IGNORECASE, count=1)
+        return result
+
+    def layer10_final_polish(self, text: str) -> str:
+        """Apply contractions and fix capitalisation/spacing."""
+        contractions = {
+            r'\bit is\b': "it's",
+            r'\bthat is\b': "that's",
+            r'\bthere is\b': "there's",
+            r'\bthey are\b': "they're",
+            r'\bwe are\b': "we're",
+            r'\byou are\b': "you're",
+            r'\bdo not\b': "don't",
+            r'\bdoes not\b': "doesn't",
+            r'\bcannot\b': "can't",
+            r'\bwill not\b': "won't",
+            r'\bwould not\b': "wouldn't",
+            r'\bshould not\b': "shouldn'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",
+        }
+        result = text
+        for pattern, contraction in contractions.items():
+            if random.random() < 0.75:
+                result = re.sub(pattern, contraction, result, flags=re.IGNORECASE)
+        result = re.sub(r'([.!?])\s+([a-z])', lambda m: m.group(1) + ' ' + m.group(2).upper(), result)
+        result = re.sub(r'  +', ' ', result)
+        result = re.sub(r'\s+([,.!?;:])', r'\1', result)
+        return result.strip()
+
+    def _ascii_cleanup(self, text: str) -> str:
+        """Replace all non-ASCII characters with simple ASCII equivalents."""
+        replacements = {
+            # Smart quotes and apostrophes
+            '\u2018': "'", '\u2019': "'",   # ' '
+            '\u201c': '"', '\u201d': '"',   # " "
+            '\u201a': "'", '\u201e': '"',   # ‚ „
+            # Dashes and ellipsis
+            '\u2014': '-',                  # em dash —
+            '\u2013': '-',                  # en dash –
+            '\u2012': '-',                  # figure dash
+            '\u2026': '...',                # ellipsis …
+            # Bullets and arrows
+            '\u2022': '-',                  # bullet •
+            '\u2023': '-',                  # triangular bullet
+            '\u2192': '->',                 # arrow →
+            '\u2190': '<-',                 # arrow ←
+            '\u2022': '-',
+            # Symbols
+            '\u00a9': '(c)',                # copyright ©
+            '\u2122': '(tm)',               # trademark ™
+            '\u00ae': '(r)',                # registered ®
+            '\u20ac': 'EUR',               # euro €
+            '\u00a3': 'GBP',               # pound £
+            '\u00b0': ' degrees',           # degree °
+            '\u00d7': 'x',                  # multiplication ×
+            '\u00f7': '/',                  # division ÷
+            '\u00bd': '1/2',               # ½
+            '\u00bc': '1/4',               # ¼
+            '\u00be': '3/4',               # ¾
+            # Accented e
+            '\u00e9': 'e', '\u00e8': 'e', '\u00ea': 'e', '\u00eb': 'e',
+            '\u00c9': 'E', '\u00c8': 'E', '\u00ca': 'E', '\u00cb': 'E',
+            # Accented a
+            '\u00e0': 'a', '\u00e2': 'a', '\u00e4': 'a', '\u00e1': 'a',
+            '\u00e3': 'a', '\u00e5': 'a',
+            '\u00c0': 'A', '\u00c2': 'A', '\u00c4': 'A', '\u00c1': 'A',
+            # Accented u
+            '\u00fc': 'u', '\u00fa': 'u', '\u00fb': 'u', '\u00f9': 'u',
+            '\u00dc': 'U', '\u00da': 'U', '\u00db': 'U', '\u00d9': 'U',
+            # Accented o
+            '\u00f3': 'o', '\u00f4': 'o', '\u00f6': 'o', '\u00f2': 'o',
+            '\u00f5': 'o', '\u00f8': 'o',
+            '\u00d3': 'O', '\u00d4': 'O', '\u00d6': 'O', '\u00d2': 'O',
+            # Accented i
+            '\u00ed': 'i', '\u00ee': 'i', '\u00ef': 'i', '\u00ec': 'i',
+            '\u00cd': 'I', '\u00ce': 'I', '\u00cf': 'I', '\u00cc': 'I',
+            # Other common accented
+            '\u00f1': 'n', '\u00d1': 'N',  # ñ Ñ
+            '\u00e7': 'c', '\u00c7': 'C',  # ç Ç
+            '\u00df': 'ss',                 # ß
+            '\u00e6': 'ae', '\u00c6': 'AE', # æ Æ
+            '\u00f0': 'd', '\u00d0': 'D',  # ð Ð
+            '\u00fe': 'th', '\u00de': 'TH', # þ Þ
+            # Non-breaking space
+            '\u00a0': ' ',
+            '\u200b': '',                   # zero-width space
+            '\u200c': '',                   # zero-width non-joiner
+            '\u200d': '',                   # zero-width joiner
+            '\ufeff': '',                   # BOM
+        }
+        for char, rep in replacements.items():
+            text = text.replace(char, rep)
+        # Remove any remaining non-ASCII (includes all emojis)
+        text = text.encode('ascii', 'ignore').decode('ascii')
+        return text
+
+    def run(self, text: str) -> str:
+        layers = [
+            ("Layer 1: AI Phrase Replacement", self.layer1_synonym_replacement),
+            ("Layer 2: Voice Variation",        self.layer2_voice_swap),
+            ("Layer 3: Filler Removal",         self.layer3_simplification),
+            ("Layer 4: Sentence Splitting",     self.layer4_sentence_separation),
+            ("Layer 5: Personal Touch",         self.layer5_personal_touch),
+            ("Layer 6: Connective Flow",        self.layer6_connective_flow),
+            ("Layer 7: Tonal Variation",        self.layer7_tonal_variation),
+            ("Layer 8: Redundancy Removal",     self.layer8_redundancy_removal),
+            ("Layer 9: Safe Synonym Pass",      self.layer9_safe_synonym_pass),
+            ("Layer 10: Final Polish",          self.layer10_final_polish),
+        ]
+        current = text
+        for name, fn in layers:
+            print(f"🔄 {name}...")
+            try:
+                current = fn(current)
+            except Exception as e:
+                print(f"⚠️  {name} failed: {e} — skipping")
+        current = self._ascii_cleanup(current)
+        current = re.sub(r'\s+', ' ', current).strip()
+        print("✅ 10-layer pipeline complete")
+        return current
+
+
+
+# ---------------------------------------------------------------------------
+
 class AdvancedAIHumanizer:
     def __init__(self):
         self.setup_models()
@@ -892,13 +1275,20 @@ class AdvancedAIHumanizer:
 def create_enhanced_interface():
     """Create the enhanced Gradio interface"""
     humanizer = AdvancedAIHumanizer()
-    
+    layered = LayeredHumanizer()
+
     def process_text_advanced(input_text, intensity):
         if not input_text or len(input_text.strip()) < 10:
             return "Please enter at least 10 characters of text to humanize.", "No analysis available."
-        
+
         try:
-            result = humanizer.humanize_text(input_text, intensity)
+            # Stage 1: 10-layer pipeline
+            print("🚀 Stage 1: Running 10-layer humanization pipeline...")
+            layered_output = layered.run(input_text)
+
+            # Stage 2: AdvancedAIHumanizer on the layered output
+            print("🚀 Stage 2: Running AdvancedAIHumanizer...")
+            result = humanizer.humanize_text(layered_output, intensity)
             analysis = humanizer.get_detailed_analysis(result)
             return result, analysis
         except Exception as e:
@@ -961,7 +1351,7 @@ def create_enhanced_interface():
         <div class="main-header">
             🧠 Advanced AI Humanizer Pro
             <div style="font-size: 0.35em; margin-top: 15px; opacity: 0.9;">
-                🎯 Guaranteed 0% AI Detection • 🔒 Meaning Preservation • ⚡ Professional Quality
+                🎯 10-Layer LLM Pipeline + Advanced NLP • 0% AI Detection • ⚡ Professional Quality
             </div>
         </div>
         """)
@@ -995,14 +1385,14 @@ def create_enhanced_interface():
             
             with gr.Column(scale=1):
                 output_text = gr.Textbox(
-                    label="✅ Humanized Content (0% AI Detection Guaranteed)", 
-                    lines=16, 
+                    label="✅ Humanized Content (0% AI Detection Guaranteed)",
+                    lines=16,
                     show_copy_button=True,
                     info="🎯 Ready for use - Bypasses all major AI detectors"
                 )
-                
+
                 analysis = gr.Textbox(
-                    label="📊 Advanced Detection Analysis", 
+                    label="📊 Advanced Detection Analysis",
                     lines=12,
                     info="📈 Detailed metrics and bypass confirmation"
                 )
@@ -1060,28 +1450,26 @@ def create_enhanced_interface():
         
         gr.HTML("""
         <div class="feature-card">
-            <h3 style="color: #2c3e50; margin-bottom: 20px;">💡 How It Works - 5-Pass Humanization Process:</h3>
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; margin: 20px 0;">
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #007bff; text-align: center;">
-                    <strong style="color: #007bff;">🔄 Pass 1: Pattern Elimination</strong><br>
-                    Removes AI-flagged words and phrases
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #28a745; text-align: center;">
-                    <strong style="color: #28a745;">🎭 Pass 2: Structure Variation</strong><br>
-                    Restructures sentences naturally
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #ffc107; text-align: center;">
-                    <strong style="color: #e65100;">📚 Pass 3: Vocabulary Enhancement</strong><br>
-                    Replaces with contextual synonyms
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #dc3545; text-align: center;">
-                    <strong style="color: #dc3545;">✨ Pass 4: Human Touches</strong><br>
-                    Adds natural contractions and flow
-                </div>
-                <div style="background: #f8f9fa; padding: 18px; border-radius: 12px; border-left: 4px solid #6f42c1; text-align: center;">
-                    <strong style="color: #6f42c1;">🎯 Pass 5: Final Polish</strong><br>
-                    Advanced paraphrasing and optimization
-                </div>
+            <h3 style="color: #2c3e50; margin-bottom: 20px;">💡 How It Works - Two-Stage Humanization:</h3>
+            <div style="margin-bottom: 18px; background: linear-gradient(135deg, #e8f5e8, #c8e6c9); padding: 18px; border-radius: 12px; border-left: 5px solid #4caf50;">
+                <strong style="color: #388e3c;">Stage 1 — 10-Layer LLM Pipeline (Gemma 3 27B)</strong><br><br>
+                Each layer is a focused LLM rewrite pass in sequence:
+            </div>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 15px; margin: 15px 0;">
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 1</strong><br>Synonym Replacement</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 2</strong><br>Active/Passive Swap</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 3</strong><br>Simplification</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 4</strong><br>Sentence Separation</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 5</strong><br>Personal Touch</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 6</strong><br>Connective Flow</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 7</strong><br>Tonal Variation</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 8</strong><br>Redundancy Removal</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 9</strong><br>Language Fragmentation</div>
+                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 10</strong><br>Reassemble to English</div>
+            </div>
+            <div style="margin-top: 18px; background: linear-gradient(135deg, #e3f2fd, #bbdefb); padding: 18px; border-radius: 12px; border-left: 5px solid #2196f3;">
+                <strong style="color: #1976d2;">Stage 2 — Advanced NLP Polish (5-Pass)</strong><br><br>
+                The Stage 1 output is fed into the multi-pass NLP engine: pattern elimination, sentence restructuring, vocabulary enhancement, contractions + human touches, and final T5 paraphrasing.
             </div>
         </div>
         """)
@@ -1109,4 +1497,4 @@ if __name__ == "__main__":
         server_port=7860, 
         show_error=True,
         share=False
-    )
+    )