Upload 3 files

app.py

@@ -0,0 +1,1539 @@
+import streamlit as st
+import requests
+from PIL import Image, ImageDraw, ImageFont
+import io
+import time
+import json
+import base64
+import uuid
+import hashlib
+import urllib.parse
+import random
+import datetime
+import re
+from collections import Counter
+from bs4 import BeautifulSoup
+from fpdf import FPDF
+import os
+from io import BytesIO
+import streamlit as st
+import html
+import string
+# --- BATCH 1: MEDIA & FILE FUNCTIONS ---
+
+def lexical_replacer_tool():
+    """
+    The Master Function for the Lexical Space Replacer Tool.
+    Contains 100+ text manipulation features split into Normal and Dev modes.
+    """
+
+    st.markdown("## 🛠️ Lexical Replacer Toolkit")
+    st.markdown("---")
+
+    # --- STATE MANAGEMENT ---
+    # We use session state to hold the text so it persists when switching tabs
+    if 'replacer_input' not in st.session_state:
+        st.session_state.replacer_input = "Paste your text or HTML here..."
+    if 'replacer_output' not in st.session_state:
+        st.session_state.replacer_output = ""
+
+    # --- THE LOGIC ENGINE (100+ Features Mapped) ---
+    # We map "Human Readable Names" to "Lambda Functions" for efficiency.
+    
+    ops = {
+        # --- GROUP 1: BASIC CLEANUP (Normal Mode) ---
+        "Remove Double Spaces": lambda t: re.sub(r'\s+', ' ', t),
+        "Trim Whitespace": lambda t: t.strip(),
+        "Remove Empty Lines": lambda t: "\n".join([line for line in t.splitlines() if line.strip()]),
+        "Remove Duplicate Lines": lambda t: "\n".join(list(dict.fromkeys(t.splitlines()))), # Preserves order
+        "Sentence Case": lambda t: ". ".join([s.capitalize() for s in t.split(". ")]),
+        "Title Case": lambda t: t.title(),
+        "UPPERCASE": lambda t: t.upper(),
+        "lowercase": lambda t: t.lower(),
+        "tOGGLE cASE": lambda t: t.swapcase(),
+        "Smart Quotes to Straight": lambda t: t.replace('“', '"').replace('”', '"').replace("‘", "'").replace("’", "'"),
+        "Remove Special Characters": lambda t: re.sub(r'[^a-zA-Z0-9\s]', '', t),
+        "Remove Emojis": lambda t: t.encode('ascii', 'ignore').decode('ascii'),
+        "Remove Numbers": lambda t: re.sub(r'\d+', '', t),
+        "Remove Non-ASCII": lambda t: re.sub(r'[^\x00-\x7F]+', '', t),
+        "Unescape HTML": lambda t: html.unescape(t),
+        "Text Reverse": lambda t: t[::-1],
+        "Word Reverse": lambda t: " ".join(t.split()[::-1]),
+        "Sort Lines A-Z": lambda t: "\n".join(sorted(t.splitlines())),
+        "Sort Lines Z-A": lambda t: "\n".join(sorted(t.splitlines(), reverse=True)),
+        "Shuffle Lines": lambda t: "\n".join(random.sample(t.splitlines(), len(t.splitlines()))),
+        
+        # --- GROUP 2: FORMATTING (Normal Mode) ---
+        "Add Line Breaks (<br>)": lambda t: t.replace("\n", "<br>\n"),
+        "Wrap in <p> Tags": lambda t: "\n".join([f"<p>{line}</p>" for line in t.splitlines() if line.strip()]),
+        "List Maker (Bullets)": lambda t: "<ul>\n" + "\n".join([f"  <li>{line}</li>" for line in t.splitlines() if line.strip()]) + "\n</ul>",
+        "List Maker (Numbered)": lambda t: "<ol>\n" + "\n".join([f"  <li>{line}</li>" for line in t.splitlines() if line.strip()]) + "\n</ol>",
+        "Markdown to HTML Bold": lambda t: re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', t),
+        "HTML to Markdown Bold": lambda t: re.sub(r'<b>(.*?)</b>', r'**\1**', t),
+        "Strip All HTML Tags": lambda t: re.sub(r'<[^>]+>', '', t),
+        "Obfuscate Emails": lambda t: re.sub(r'([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})', r'[email protected]', t),
+        "Format Date (DD/MM/YYYY)": lambda t: t, # Placeholder for complex regex
+        "Tab to 4 Spaces": lambda t: t.replace("\t", "    "),
+        "Slugify (URL Friendly)": lambda t: re.sub(r'[^a-z0-9]+', '-', t.lower()).strip('-'),
+        "Add Target='_blank'": lambda t: t.replace('<a ', '<a target="_blank" '),
+        "Add Rel='nofollow'": lambda t: t.replace('<a ', '<a rel="nofollow" '),
+        
+        # --- GROUP 3: DEV UTILS (Dev Mode) ---
+        "Minify JSON": lambda t: json.dumps(json.loads(t), separators=(',', ':')) if t.strip() else "",
+        "Beautify JSON": lambda t: json.dumps(json.loads(t), indent=4) if t.strip() else "",
+        "Escape HTML Entities": lambda t: html.escape(t),
+        "Escape JSON String": lambda t: json.dumps(t),
+        "Base64 Encode": lambda t: base64.b64encode(t.encode()).decode(),
+        "Base64 Decode": lambda t: base64.b64decode(t.encode()).decode(),
+        "URL Encode": lambda t: urllib.parse.quote(t),
+        "URL Decode": lambda t: urllib.parse.unquote(t),
+        "Hex to RGB": lambda t: "\n".join([f"rgb({int(h[1:3], 16)}, {int(h[3:5], 16)}, {int(h[5:7], 16)})" for h in re.findall(r'#[0-9a-fA-F]{6}', t)]),
+        
+        # --- GROUP 4: BLOGGER SPECIFIC (Dev Mode) ---
+        "Blogger: Fix Image Sizes": lambda t: re.sub(r'(width|height)="\d+"', '', t),
+        "Blogger: HTTPS Force": lambda t: t.replace("http://", "https://"),
+        "Clean MS Word Junk": lambda t: re.sub(r'class="Mso.*?"', '', t),
+        "Remove Inline Styles": lambda t: re.sub(r'style=".*?"', '', t),
+        "Remove Script Tags": lambda t: re.sub(r'<script.*?>.*?</script>', '', t, flags=re.DOTALL),
+        "Remove Comments": lambda t: re.sub(r'', '', t, flags=re.DOTALL),
+    }
+
+    # --- LAYOUT ---
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("Input")
+        text_input = st.text_area("Paste text here", value=st.session_state.replacer_input, height=350, key="input_widget")
+        
+        # Update session state on change
+        if text_input != st.session_state.replacer_input:
+            st.session_state.replacer_input = text_input
+
+    with col2:
+        st.subheader("Control Panel")
+        
+        mode = st.radio("Select Mode:", ["🟢 Normal Mode", "🔴 Developer Mode"], horizontal=True)
+        
+        selected_ops = []
+        
+        if mode == "🟢 Normal Mode":
+            st.info("Tools for Writing, SEO, and Formatting")
+            with st.expander("✨ Cleaning Tools", expanded=True):
+                if st.button("Remove Double Spaces"): selected_ops.append("Remove Double Spaces")
+                if st.button("Trim Whitespace"): selected_ops.append("Trim Whitespace")
+                if st.button("Remove Empty Lines"): selected_ops.append("Remove Empty Lines")
+                if st.button("Remove Duplicate Lines"): selected_ops.append("Remove Duplicate Lines")
+                if st.button("Remove Special Chars"): selected_ops.append("Remove Special Characters")
+            
+            with st.expander("🔠 Casing Tools"):
+                c1, c2, c3 = st.columns(3)
+                with c1: 
+                    if st.button("UPPERCASE"): selected_ops.append("UPPERCASE")
+                    if st.button("Sentence Case"): selected_ops.append("Sentence Case")
+                with c2: 
+                    if st.button("lowercase"): selected_ops.append("lowercase")
+                    if st.button("Title Case"): selected_ops.append("Title Case")
+                with c3: 
+                    if st.button("Toggle Case"): selected_ops.append("tOGGLE cASE")
+            
+            with st.expander("📄 Formatting"):
+                if st.button("Make HTML List (Bullet)"): selected_ops.append("List Maker (Bullets)")
+                if st.button("Make HTML List (Number)"): selected_ops.append("List Maker (Numbered)")
+                if st.button("Smart Quotes -> Straight"): selected_ops.append("Smart Quotes to Straight")
+                if st.button("Slugify Text"): selected_ops.append("Slugify (URL Friendly)")
+
+        else: # Developer Mode
+            st.error("Tools for Code, Regex, and Backend")
+            
+            # Regex Section
+            with st.expander("🔍 Regex Find & Replace", expanded=True):
+                regex_find = st.text_input("Find Pattern (Regex)", value="")
+                regex_repl = st.text_input("Replace With", value="")
+                if st.button("Run Regex Replace"):
+                    try:
+                        st.session_state.replacer_input = re.sub(regex_find, regex_repl, st.session_state.replacer_input)
+                        st.success("Regex Applied!")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Regex Error: {e}")
+
+            with st.expander("💻 Encoders / Decoders"):
+                c1, c2 = st.columns(2)
+                with c1:
+                    if st.button("Base64 Encode"): selected_ops.append("Base64 Encode")
+                    if st.button("URL Encode"): selected_ops.append("URL Encode")
+                with c2:
+                    if st.button("Base64 Decode"): selected_ops.append("Base64 Decode")
+                    if st.button("URL Decode"): selected_ops.append("URL Decode")
+            
+            with st.expander("🧹 Code Cleaning"):
+                if st.button("Minify JSON"): selected_ops.append("Minify JSON")
+                if st.button("Beautify JSON"): selected_ops.append("Beautify JSON")
+                if st.button("Escape HTML"): selected_ops.append("Escape HTML Entities")
+            
+            with st.expander("🅱️ Blogger Specific"):
+                if st.button("Clean MS Word Junk"): selected_ops.append("Clean MS Word Junk")
+                if st.button("Force HTTPS"): selected_ops.append("Blogger: HTTPS Force")
+                if st.button("Remove Inline Styles"): selected_ops.append("Remove Inline Styles")
+                if st.button("Remove Scripts"): selected_ops.append("Remove Script Tags")
+
+        # --- ANALYSIS (Always Visible) ---
+        st.write("---")
+        st.caption("📊 Live Analysis")
+        char_count = len(st.session_state.replacer_input)
+        word_count = len(st.session_state.replacer_input.split())
+        st.write(f"**Chars:** {char_count} | **Words:** {word_count}")
+
+    # --- EXECUTION ENGINE ---
+    # If a button added an op to the list, run it against the input text
+    if selected_ops:
+        current_text = st.session_state.replacer_input
+        for op_name in selected_ops:
+            try:
+                # Apply the function from our dictionary
+                current_text = ops[op_name](current_text)
+                st.toast(f"Applied: {op_name}")
+            except Exception as e:
+                st.error(f"Error in {op_name}: {e}")
+        
+        # Update State
+        st.session_state.replacer_input = current_text
+        st.rerun() # Refresh to show changes in the text area
+
+    # --- RESULT DOWNLOAD ---
+    if st.session_state.replacer_input:
+        st.download_button(
+            label="Download Result",
+            data=st.session_state.replacer_input,
+            file_name="lexical_cleaned.txt",
+            mime="text/plain"
+        )
+
+
+    
+
+
+def run_ultimate_pdf_converter():
+    """
+    The Ultimate Text-to-PDF Converter (Stable Version).
+    Features: 
+    - Auto-Healing Font Loader (Fixes TTLibError)
+    - Smart Symbols & Typography
+    - Markdown Engine (Headers, Tables, Code Blocks)
+    - LMS Junk Cleaner
+    """
+
+    # --- CONSTANTS ---
+    SMART_SYMBOLS = {
+        r'<->': '↔', r'->': '→', r'<-': '←', r'=>': '⇒', r'<=': '≤', r'>=': '≥', r'!=': '≠',
+        r'\.\.\.': '…', r'\(c\)': '©', r'\(r\)': '®', r'\(tm\)': '™',
+        r'\+-': '±', r'\~=': '≈', r'--': '—',
+        r'alpha': 'α', r'beta': 'β', r'theta': 'θ', r'pi': 'π', r'sigma': 'Σ',
+        r'delta': 'Δ', r'gamma': 'Γ', r'omega': 'Ω', r'mu': 'μ', r'lambda': 'λ',
+        r'deg': '°', r'infinity': '∞', r'sqrt': '√'
+    }
+
+    # --- INTERNAL PDF CLASS ---
+    class UltimatePDF(FPDF):
+        def __init__(self, orientation='P', unit='mm', format='A4'):
+            super().__init__(orientation=orientation, unit=unit, format=format)
+            self.set_auto_page_break(auto=True, margin=15)
+            self.main_font = 'Arial' # Default fallback
+            self.ensure_fonts()
+
+        def ensure_fonts(self):
+            font_filename = "DejaVuSans.ttf"
+            font_url = "https://github.com/dejavu-fonts/dejavu-fonts/raw/master/ttf/DejaVuSans.ttf"
+            
+            # 1. Check if file exists and is valid size (HTML error pages are small)
+            if os.path.exists(font_filename):
+                if os.path.getsize(font_filename) < 1000: # Less than 1KB is definitely garbage
+                    os.remove(font_filename)
+            
+            # 2. Download if missing
+            if not os.path.exists(font_filename):
+                try:
+                    # Fake user-agent to avoid GitHub blocking scripts
+                    headers = {'User-Agent': 'Mozilla/5.0'} 
+                    r = requests.get(font_url, headers=headers, timeout=10)
+                    if r.status_code == 200:
+                        with open(font_filename, "wb") as f:
+                            f.write(r.content)
+                except Exception as e:
+                    print(f"Font download failed: {e}")
+
+            # 3. Try Loading the Font
+            try:
+                if os.path.exists(font_filename):
+                    self.add_font('DejaVu', '', font_filename, uni=True)
+                    self.main_font = 'DejaVu'
+            except Exception:
+                # If loading fails (corrupt file), delete it to retry next time
+                try: os.remove(font_filename) 
+                except: pass
+                self.main_font = 'Arial' # Fallback to standard
+                st.toast("⚠️ Font failed to load. Using standard font (some symbols may be missing).", icon="⚠️")
+
+        def header(self):
+            if getattr(self, 'show_header', False):
+                self.set_font(self.main_font, '', 8)
+                self.set_text_color(128)
+                self.cell(0, 10, f'Generated by Ultimate PDF | {getattr(self, "title_meta", "Doc")}', 0, 0, 'R')
+                self.ln(10)
+
+        def footer(self):
+            self.set_y(-15)
+            self.set_font(self.main_font, '', 8)
+            self.set_text_color(128)
+            self.cell(0, 10, f'Page {self.page_no()}', 0, 0, 'C')
+
+        # --- MARKDOWN RENDERING HELPERS ---
+        def add_markdown_header(self, text, level):
+            sizes = {1: 20, 2: 16, 3: 14}
+            self.set_font(self.main_font, '', sizes.get(level, 12))
+            self.set_text_color(0, 50, 100) 
+            self.cell(0, 10, text, ln=True)
+            self.set_text_color(0)
+            self.set_font(self.main_font, '', 12)
+
+        def add_code_block(self, code_lines):
+            self.set_font("Courier", size=10)
+            self.set_fill_color(245, 245, 245)
+            for line in code_lines:
+                # Replace tabs with spaces to prevent alignment issues
+                safe_line = line.replace('\t', '    ') 
+                self.cell(0, 5, safe_line, ln=True, fill=True, border=0)
+            self.set_font(self.main_font, '', 12)
+            self.ln(3)
+
+        def add_table(self, table_lines):
+            self.set_font(self.main_font, '', 10)
+            cell_h = 7
+            for row in table_lines:
+                cols = [c.strip() for c in row.split('|') if c.strip()]
+                if not cols: continue
+                col_w = (self.w - 30) // len(cols)
+                for col in cols:
+                    self.cell(col_w, cell_h, col, border=1)
+                self.ln()
+            self.set_font(self.main_font, '', 12)
+            self.ln(5)
+
+        def add_blockquote(self, text):
+            self.set_text_color(80)
+            self.set_x(self.l_margin + 8)
+            self.multi_cell(0, 6, f"“ {text}")
+            self.set_x(self.l_margin)
+            self.set_text_color(0)
+            self.ln(2)
+
+        def add_image_from_url(self, url):
+            try:
+                r = requests.get(url, timeout=5)
+                if r.status_code == 200:
+                    img_data = BytesIO(r.content)
+                    self.image(img_data, w=100)
+                    self.ln(5)
+            except:
+                self.set_text_color(200, 0, 0)
+                self.cell(0, 10, f"[Image load failed: {url}]", ln=True)
+                self.set_text_color(0)
+
+    # --- TEXT PROCESSOR ---
+    def clean_and_parse(raw_text, use_smart_symbols=True, clean_lms=True):
+        processed_lines = []
+        
+        # 1. LMS Regex Cleaning
+        if clean_lms:
+            # Common LMS patterns
+            patterns = [
+                r'\[ID:?\s*\w+\]',             # [ID: 123]
+                r'Question\s+ID\s*[:\-]\s*\w+', # Question ID: 123
+                r'\(\d+\s*pts?\)',              # (1 pts)
+                r'Select one:',                 # Moodle/Blackboard prompt
+                r'\[\d{1,2}:\d{2}\s*(AM|PM)?\]' # Timestamps
+            ]
+            for p in patterns:
+                raw_text = re.sub(p, '', raw_text, flags=re.IGNORECASE)
+            raw_text = re.sub(r'\n{3,}', '\n\n', raw_text) # Fix spacing
+
+        # 2. Smart Symbols
+        if use_smart_symbols:
+            for pattern, symbol in SMART_SYMBOLS.items():
+                if pattern.isalpha():
+                    raw_text = re.sub(r'\b' + pattern + r'\b', symbol, raw_text, flags=re.IGNORECASE)
+                else:
+                    raw_text = re.sub(pattern, symbol, raw_text)
+
+        lines = raw_text.split('\n')
+        
+        # 3. Block Parser
+        buffer_type = None 
+        buffer_content = []
+
+        for line in lines:
+            line_stripped = line.strip()
+
+            # Detect Code Block
+            if line_stripped.startswith('```'):
+                if buffer_type == 'code': # Close code
+                    processed_lines.append({'type': 'code', 'content': buffer_content})
+                    buffer_content = []
+                    buffer_type = None
+                else: # Open code
+                    if buffer_type == 'table': # Close table if open
+                        processed_lines.append({'type': 'table', 'content': buffer_content})
+                        buffer_content = []
+                    buffer_type = 'code'
+                continue
+            
+            if buffer_type == 'code':
+                buffer_content.append(line) # Preserve whitespace in code
+                continue
+
+            # Detect Table
+            if '|' in line_stripped and len(line_stripped) > 3:
+                if buffer_type != 'table':
+                    buffer_type = 'table'
+                buffer_content.append(line_stripped)
+                continue
+            elif buffer_type == 'table': # Close table
+                processed_lines.append({'type': 'table', 'content': buffer_content})
+                buffer_content = []
+                buffer_type = None
+
+            # Detect Headers
+            if line_stripped.startswith('#'):
+                level = line_stripped.count('#')
+                text = line_stripped.replace('#', '').strip()
+                processed_lines.append({'type': 'header', 'level': min(level, 3), 'content': text})
+                continue
+
+            # Detect Quotes
+            if line_stripped.startswith('> '):
+                processed_lines.append({'type': 'quote', 'content': line_stripped[2:]})
+                continue
+
+            # Detect Images
+            if line_stripped.startswith('http') and line_stripped.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
+                processed_lines.append({'type': 'image', 'url': line_stripped})
+                continue
+
+            # Detect Lists
+            if line_stripped.startswith(('* ', '- ')):
+                 processed_lines.append({'type': 'list', 'content': line_stripped[2:]})
+                 continue
+            
+            # Detect HR
+            if line_stripped == '---':
+                 processed_lines.append({'type': 'hr'})
+                 continue
+
+            if line_stripped:
+                processed_lines.append({'type': 'text', 'content': line_stripped})
+            else:
+                 processed_lines.append({'type': 'empty'})
+
+        if buffer_type == 'table': 
+            processed_lines.append({'type': 'table', 'content': buffer_content})
+        
+        return processed_lines
+
+    # --- UI RENDER ---
+    st.title("⚡ Ultimate PDF Engine")
+    
+    with st.expander("ℹ️ Help & Features", expanded=False):
+        st.write("- **Smart Symbols:** Writes 'alpha' as α, '->' as →")
+        st.write("- **Tables:** Use `| Name | Score |` format")
+        st.write("- **Code:** Use ` ``` ` for code blocks")
+        st.write("- **Images:** Paste URL on new line")
+
+    # Settings Sidebar
+    with st.sidebar:
+        st.header("⚙️ PDF Config")
+        filename = st.text_input("Filename", "My_Notes.pdf")
+        orientation = st.radio("Orientation", ["Portrait", "Landscape"])
+        st.subheader("Filters")
+        enable_lms = st.checkbox("Clean LMS Junk", True)
+        enable_smart = st.checkbox("Smart Symbols", True)
+        enable_header = st.checkbox("Show Header", True)
+        font_size = st.slider("Font Size", 8, 24, 12)
+
+    # Input
+    raw_input = st.text_area("Paste text here...", height=350)
+
+    # Action
+    if st.button("🚀 Generate PDF", type="primary"):
+        if not raw_input.strip():
+            st.warning("Input is empty.")
+            return
+
+        with st.spinner("Processing..."):
+            # Setup PDF
+            orient_code = 'P' if orientation == "Portrait" else 'L'
+            pdf = UltimatePDF(orientation=orient_code)
+            pdf.title_meta = filename.replace('.pdf', '')
+            pdf.show_header = enable_header
+            
+            pdf.add_page()
+            pdf.set_font(pdf.main_font, '', font_size)
+
+            # Process
+            blocks = clean_and_parse(raw_input, use_smart_symbols=enable_smart, clean_lms=enable_lms)
+
+            # Render
+            for block in blocks:
+                if block['type'] == 'header':
+                    pdf.add_markdown_header(block['content'], block['level'])
+                elif block['type'] == 'code':
+                    pdf.add_code_block(block['content'])
+                elif block['type'] == 'table':
+                    pdf.add_table(block['content'])
+                elif block['type'] == 'quote':
+                    pdf.add_blockquote(block['content'])
+                elif block['type'] == 'image':
+                    pdf.add_image_from_url(block['url'])
+                elif block['type'] == 'list':
+                    pdf.set_x(pdf.l_margin + 5)
+                    pdf.write(8, f"• {block['content']}")
+                    pdf.ln()
+                    pdf.set_x(pdf.l_margin)
+                elif block['type'] == 'hr':
+                    pdf.ln(2)
+                    pdf.line(pdf.l_margin, pdf.get_y(), pdf.w - pdf.r_margin, pdf.get_y())
+                    pdf.ln(5)
+                elif block['type'] == 'text':
+                    pdf.write(8, block['content'])
+                    pdf.ln()
+                elif block['type'] == 'empty':
+                    pdf.ln(4)
+
+            # Download
+            try:
+                pdf_bytes = pdf.output(dest='S').encode('latin-1', 'replace')
+                st.success("PDF Generated Successfully!")
+                st.download_button(
+                    "⬇️ Download PDF",
+                    data=pdf_bytes,
+                    file_name=filename if filename.endswith('.pdf') else f"{filename}.pdf",
+                    mime="application/pdf"
+                )
+            except Exception as e:
+                st.error(f"Error creating PDF file: {e}")
+
+
+
+    
+
+    
+import streamlit as st
+from huggingface_hub import InferenceClient
+import os
+
+# --- 1. The Logic Function (Backend) ---
+# We use @st.cache_data so if the user clicks other buttons, we don't re-run the expensive API call.
+@st.cache_data(show_spinner="Analyzing code with Qwen AI...")
+def get_seo_data(code_snippet, file_type, api_key):
+    """
+    Sends code to Hugging Face Inference API and returns SEO/JSON-LD strategy.
+    """
+    if not code_snippet:
+        return None, "⚠️ Please paste some code first."
+    
+    if not api_key:
+        return None, "❌ Error: HF_TOKEN not found in secrets."
+
+    try:
+        client = InferenceClient(api_key=api_key)
+        
+        # Strict Prompt for Qwen 2.5 Coder
+        system_instruction = f"""
+        You are an expert Technical SEO Specialist. Analyze the user's {file_type} code.
+        
+        Task: Generate Google-compliant JSON-LD structured data and SEO meta tags.
+        
+        Output Format (Strict Markdown):
+        ## SEO Metadata
+        **Title:** [Engaging Title, max 60 chars]
+        **Description:** [Summary including keywords, max 160 chars]
+        **Keywords:** [5-8 comma-separated keywords]
+        
+        ## JSON-LD Structured Data
+        ```json
+        [Insert VALID JSON-LD here. 
+         - If Python: Use schema.org/SoftwareSourceCode
+         - If HTML: Use schema.org/WebPage or schema.org/TechArticle]
+        ```
+        """
+        
+        user_message = f"Analyze this {file_type} code:\n\n{code_snippet}"
+
+        response = client.chat_completion(
+            model="Qwen/Qwen2.5-Coder-32B-Instruct",
+            messages=[
+                {"role": "system", "content": system_instruction},
+                {"role": "user", "content": user_message}
+            ],
+            max_tokens=1500,
+            temperature=0.2
+        )
+        return response.choices[0].message.content, None
+
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+# --- 2. The UI Function (Frontend) ---
+def render_seo_ui():
+    """
+    Call this function in your main app.py where you want the SEO tool to show up.
+    """
+    st.header("🚀 AI Code-to-SEO Generator")
+    st.markdown("Generate **JSON-LD** and **Meta Tags** for your Python/HTML files using Qwen 2.5 Coder.")
+
+    # Get Token (Try secrets first, then env var)
+    try:
+        hf_token = st.secrets["HF_TOKEN"]
+    except:
+        hf_token = os.getenv("HF_TOKEN")
+
+    with st.form("seo_form"):
+        col1, col2 = st.columns([1, 3])
+        
+        with col1:
+            file_type = st.radio("File Type", ["Python", "HTML"])
+        
+        with col2:
+            code_input = st.text_area("Paste Code Here", height=300, placeholder="import os...")
+            
+        submitted = st.form_submit_button("✨ Generate SEO Data")
+
+    if submitted:
+        if not hf_token:
+            st.error("Authentication Error: Please add `HF_TOKEN` to your Streamlit secrets.")
+        else:
+            result, error = get_seo_data(code_input, file_type, hf_token)
+            
+            if error:
+                st.error(error)
+            else:
+                st.success("SEO Data Generated Successfully!")
+                st.markdown("---")
+                st.markdown(result)
+                
+                # Optional: Add a copy button for the raw result
+                st.download_button(
+                    label="📥 Download Result",
+                    data=result,
+                    file_name="seo_strategy.md",
+                    mime="text/markdown"
+                )
+
+
+    
+
+def tool_youtube_downloader():
+    st.header("🎥 YouTube Media Extractor")
+    url = st.text_input("Paste YouTube URL", placeholder="https://youtube.com/...")
+    format_type = st.radio("Format", ["Video (MP4)", "Audio Only (MP3)"], horizontal=True)
+    
+    if url and st.button("🚀 Process Media"):
+        with st.spinner("Contacting server..."):
+            try:
+                headers = {"Accept": "application/json", "Content-Type": "application/json"}
+                payload = {
+                    "url": url,
+                    "vQuality": "1080",
+                    "isAudioOnly": True if "Audio" in format_type else False
+                }
+                # Using Cobalt API
+                response = requests.post("https://api.cobalt.tools/api/json", headers=headers, json=payload)
+                data = response.json()
+                
+                if "url" in data:
+                    st.success("✅ Ready!")
+                    st.link_button(f"⬇️ Download {format_type}", data["url"])
+                    if "Audio" not in format_type:
+                        st.video(data["url"])
+                    else:
+                        st.audio(data["url"])
+                else:
+                    st.error(f"Error: {data.get('text', 'Unknown error')}")
+            except Exception as e:
+                st.error(f"Connection failed: {str(e)}")
+
+def tool_smart_converter():
+    with st.spinner("Starting File Engine..."):
+        
+        time.sleep(0.3)
+    
+    
+        import pandas as pd
+    st.header("🔄 Smart File Converter")
+    st.info("Supports: Images (PNG/JPG/WEBP) and Data (CSV/JSON/Excel)")
+    
+    uploaded_file = st.file_uploader("Upload File", type=['png', 'jpg', 'jpeg', 'webp', 'csv', 'json', 'xlsx'],key="smart_conv_upload")
+    
+    if uploaded_file:
+        file_type = uploaded_file.name.split('.')[-1].lower()
+        
+        # LOGIC: IMAGE CONVERSION
+        if file_type in ['png', 'jpg', 'jpeg', 'webp']:
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Preview", width=300)
+            target_format = st.selectbox("Convert to:", ["PNG", "JPEG", "WEBP", "PDF"])
+            
+            if st.button("Convert Image"):
+                buf = io.BytesIO()
+                # RGB required for JPEG/PDF
+                if image.mode in ("RGBA", "P") and target_format in ["JPEG", "PDF"]:
+                    image = image.convert("RGB")
+                
+                image.save(buf, format=target_format)
+                st.download_button(f"Download {target_format}", data=buf.getvalue(), file_name=f"converted.{target_format.lower()}")
+
+        # LOGIC: DATA CONVERSION
+        elif file_type in ['csv', 'json', 'xlsx']:
+            df = None
+            try:
+                if file_type == 'csv': df = pd.read_csv(uploaded_file)
+                elif file_type == 'json': df = pd.read_json(uploaded_file)
+                elif file_type == 'xlsx': df = pd.read_excel(uploaded_file)
+                
+                st.write("Data Preview:", df.head())
+                target_data = st.selectbox("Convert to:", ["CSV", "JSON", "Excel"])
+                
+                if st.button("Convert Data"):
+                    buf = io.BytesIO()
+                    if target_data == "CSV":
+                        df.to_csv(buf, index=False)
+                        ext = "csv"
+                    elif target_data == "JSON":
+                        df.to_json(buf, orient='records')
+                        ext = "json"
+                    elif target_data == "Excel":
+                        df.to_excel(buf, index=False)
+                        ext = "xlsx"
+                    
+                    st.download_button(f"Download {target_data}", data=buf.getvalue(), file_name=f"converted.{ext}")
+            except Exception as e:
+                st.error(f"Error reading file: {e}")
+
+def tool_image_compressor():
+    st.header("📉 Image Compressor")
+    # ADD key="compressor"
+    uploaded_file = st.file_uploader("Upload Image", type=['png', 'jpg', 'jpeg'], key="compressor") 
+    
+    
+    
+    if uploaded_file:
+        image = Image.open(uploaded_file)
+        st.write(f"Original Size: {uploaded_file.size / 1024:.2f} KB")
+        quality = st.slider("Quality (Lower = Smaller file)", 10, 95, 60)
+        
+        if st.button("Compress"):
+            buf = io.BytesIO()
+            if image.mode in ("RGBA", "P"): image = image.convert("RGB")
+            image.save(buf, format="JPEG", quality=quality, optimize=True)
+            
+            size_kb = len(buf.getvalue()) / 1024
+            st.success(f"Compressed Size: {size_kb:.2f} KB")
+            st.download_button("Download Compressed Image", data=buf.getvalue(), file_name="compressed.jpg")
+
+def tool_image_resizer():
+    st.header("📐 Image Resizer")
+    # ADD key="resizer"
+    uploaded_file = st.file_uploader("Upload Image", type=['png', 'jpg', 'jpeg', 'webp'], key="resizer")
+    
+   
+    
+    if uploaded_file:
+        image = Image.open(uploaded_file)
+        st.write(f"Current Dimensions: {image.size}")
+        
+        col1, col2 = st.columns(2)
+        w = col1.number_input("Width", value=image.width)
+        h = col2.number_input("Height", value=image.height)
+        
+        if st.button("Resize"):
+            new_img = image.resize((int(w), int(h)))
+            buf = io.BytesIO()
+            new_img.save(buf, format=image.format)
+            st.image(new_img, caption="Resized Preview")
+            st.download_button("Download Resized Image", data=buf.getvalue(), file_name=f"resized.{image.format.lower()}")
+
+def tool_thumbnail_generator():
+    st.header("🚀 Ultimate Thumbnail Studio")
+    
+    # --- DEPENDENCIES ---
+    from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance, ImageOps, ImageColor
+    import io
+
+    # --- LAYOUT FIX FOR PC/MOBILE ---
+    # We use a container for the controls to keep them tidy on PC
+    # and "use_column_width" to fix the crash.
+    
+    # Top row: All Controls (Split into 2 columns for better PC spacing)
+    with st.expander("🎨 Thumbnail Settings & Controls", expanded=True):
+        col_c1, col_c2 = st.columns(2)
+        
+        # --- LEFT CONTROL COLUMN ---
+        with col_c1:
+            st.subheader("1. Background & Filters")
+            bg_mode = st.radio("Background Type", ["Upload Image", "Solid Color", "Gradient"], horizontal=True)
+            
+            bg_image = None
+            if bg_mode == "Upload Image":
+                bg_file = st.file_uploader("Upload BG", type=['png', 'jpg', 'jpeg', 'webp'], key="max_bg")
+                if bg_file: bg_image = Image.open(bg_file).convert("RGBA")
+            elif bg_mode == "Solid Color":
+                hex_bg = st.color_picker("Pick Color", "#1E1E1E")
+                st.session_state.thumb_bg_color = hex_bg
+            else: # Gradient
+                c1_col, c2_col = st.columns(2)
+                grad_c1 = c1_col.color_picker("Start", "#12c2e9")
+                grad_c2 = c2_col.color_picker("End", "#c471ed")
+                grad_dir = st.selectbox("Direction", ["Horizontal", "Vertical"])
+
+            st.markdown("---")
+            st.write("**Filters**")
+            f1, f2 = st.columns(2)
+            blur_amt = f1.slider("Blur", 0, 20, 0)
+            brightness = f2.slider("Brightness", 0.5, 1.5, 1.0)
+            
+        # --- RIGHT CONTROL COLUMN ---
+        with col_c2:
+            st.subheader("2. Text & Branding")
+            main_text = st.text_area("Main Title", "THE ULTIMATE\nGUIDE TO PYTHON", height=100)
+            
+            t1, t2 = st.columns(2)
+            font_size = t1.slider("Size", 20, 200, 80)
+            font_color = t2.color_picker("Text Color", "#FFFFFF")
+            
+            st.write("**Styling**")
+            s1, s2 = st.columns(2)
+            stroke_width = s1.slider("Outline", 0, 10, 2)
+            stroke_color = s2.color_picker("Outline Color", "#000000")
+            
+            st.markdown("---")
+            logo_file = st.file_uploader("Upload Logo (PNG)", type=['png', 'webp'], key="max_logo")
+            if logo_file:
+                l1, l2 = st.columns(2)
+                logo_size = l1.slider("Logo Size", 50, 300, 150)
+                logo_pos = l2.selectbox("Position", ["Top-Right", "Top-Left", "Bottom-Right", "Bottom-Left"])
+            else:
+                logo_size = 150
+                logo_pos = "Top-Right"
+
+    # --- PREVIEW SECTION (Full Width for PC clarity) ---
+    st.subheader("👁️ Preview & Download")
+    
+    # GENERATION LOGIC
+    CANVAS_W, CANVAS_H = 1280, 720
+    canvas = Image.new("RGBA", (CANVAS_W, CANVAS_H), (0,0,0,0))
+    
+    # 1. Background
+    if bg_mode == "Upload Image" and bg_image:
+        bg_ratio = bg_image.width / bg_image.height
+        target_ratio = CANVAS_W / CANVAS_H
+        if bg_ratio > target_ratio:
+            new_h = CANVAS_H
+            new_w = int(new_h * bg_ratio)
+        else:
+            new_w = CANVAS_W
+            new_h = int(new_w / bg_ratio)
+        bg_image = bg_image.resize((new_w, new_h), Image.Resampling.LANCZOS)
+        left = (new_w - CANVAS_W)/2
+        top = (new_h - CANVAS_H)/2
+        bg_image = bg_image.crop((left, top, left+CANVAS_W, top+CANVAS_H))
+        canvas.paste(bg_image, (0,0))
+    elif bg_mode == "Gradient":
+        base = Image.new('RGB', (CANVAS_W, CANVAS_H), grad_c1)
+        top_img = Image.new('RGB', (CANVAS_W, CANVAS_H), grad_c2)
+        mask = Image.new("L", (CANVAS_W, CANVAS_H))
+        mask_data = []
+        for y in range(CANVAS_H):
+            for x in range(CANVAS_W):
+                if grad_dir == "Vertical": mask_data.append(int(255 * (y / CANVAS_H)))
+                else: mask_data.append(int(255 * (x / CANVAS_W)))
+        mask.putdata(mask_data)
+        canvas = Image.composite(top_img, base, mask).convert("RGBA")
+    else:
+        if 'thumb_bg_color' not in st.session_state: st.session_state.thumb_bg_color = "#1E1E1E"
+        canvas = Image.new("RGBA", (CANVAS_W, CANVAS_H), st.session_state.thumb_bg_color)
+
+    # 2. Filters
+    if blur_amt > 0: canvas = canvas.filter(ImageFilter.GaussianBlur(blur_amt))
+    if brightness != 1.0:
+        enhancer = ImageEnhance.Brightness(canvas)
+        canvas = enhancer.enhance(brightness)
+
+    # 3. Text
+    txt_layer = Image.new("RGBA", canvas.size, (255,255,255,0))
+    draw = ImageDraw.Draw(txt_layer)
+    
+    try:
+        font = ImageFont.truetype("arialbd.ttf", font_size)
+    except:
+        try:
+            font = ImageFont.truetype("arial.ttf", font_size)
+        except:
+            font = ImageFont.load_default()
+
+    # Center Text Calculation
+    # Using basic textsize for compatibility if textbbox fails in older Pillow
+    try:
+        bbox = draw.multiline_textbbox((0,0), main_text, font=font, align="center")
+        text_w = bbox[2] - bbox[0]
+        text_h = bbox[3] - bbox[1]
+    except:
+        # Fallback for very old Pillow versions
+        text_w, text_h = draw.textsize(main_text, font=font)
+
+    cx, cy = CANVAS_W // 2, CANVAS_H // 2
+    text_x = cx - (text_w // 2)
+    text_y = cy - (text_h // 2)
+
+    # Shadow
+    draw.multiline_text((text_x + 8, text_y + 8), main_text, font=font, align="center", fill="black")
+    # Main Text
+    draw.multiline_text((text_x, text_y), main_text, font=font, align="center", fill=font_color, stroke_width=stroke_width, stroke_fill=stroke_color)
+
+    # 4. Logo
+    if logo_file:
+        logo = Image.open(logo_file).convert("RGBA")
+        logo.thumbnail((logo_size, logo_size), Image.Resampling.LANCZOS)
+        pad = 30
+        if "Top" in logo_pos: ly = pad
+        elif "Bottom" in logo_pos: ly = CANVAS_H - logo.height - pad
+        if "Left" in logo_pos: lx = pad
+        elif "Right" in logo_pos: lx = CANVAS_W - logo.width - pad
+        txt_layer.paste(logo, (lx, ly), logo)
+
+    # Final Composite
+    final_comp = Image.alpha_composite(canvas, txt_layer)
+
+    # --- DISPLAY & DOWNLOAD ---
+    # Centered layout for PC look
+    col_show, col_down = st.columns([3, 1])
+    
+    with col_show:
+        # FIX: Changed use_container_width to use_column_width
+        st.image(final_comp, caption="Result", use_column_width=True) 
+        
+    with col_down:
+        st.write("### Ready?")
+        buf = io.BytesIO()
+        final_comp.convert("RGB").save(buf, format="PNG")
+        st.download_button("💾 Download PNG", data=buf.getvalue(), file_name="thumbnail.png", mime="image/png")
+# --- MAIN ROUTER (Paste this at the VERY END of app.py) ---
+# This checks the URL params and decides which function to run
+if __name__ == "__main__":
+    st.set_page_config(page_title="Lexical Space Tools", layout="centered")
+    
+    # Get the 'mode' from the URL (e.g. ?mode=youtube)
+    params = st.query_params
+    mode = params.get("mode", "home")
+
+    
+    
+        
+        
+# --- BATCH 2: WEBMASTER & SEO FUNCTIONS ---
+
+def tool_meta_tag_generator():
+    st.header("🏷️ Meta Tag Generator")
+    title = st.text_input("Site Title", "My Awesome Blog")
+    desc = st.text_area("Description", "A blog about technology and coding.")
+    keywords = st.text_input("Keywords (comma separated)", "tech, coding, python")
+    author = st.text_input("Author", "Lexical Space")
+    
+    if st.button("Generate Tags"):
+        code = f"""
+<title>{title}</title>
+<meta name="description" content="{desc}">
+<meta name="keywords" content="{keywords}">
+<meta name="author" content="{author}">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<meta property="og:type" content="website">
+<meta property="og:title" content="{title}">
+<meta property="og:description" content="{desc}">
+        """
+        st.code(code, language="html")
+
+def tool_slug_generator():
+    st.header("🐌 URL Slug Generator")
+    text = st.text_input("Enter Post Title", "How to Install Python on Windows 10!")
+    
+    if text:
+        # Lowercase, strip whitespace, replace spaces with dashes, remove non-alphanumeric
+        slug = text.lower().strip()
+        slug = re.sub(r'[^a-z0-9\s-]', '', slug)
+        slug = re.sub(r'[\s-]+', '-', slug)
+        st.success(f"Slug: {slug}")
+        st.code(slug, language="text")
+
+def tool_robots_generator():
+    st.header("🤖 Robots.txt Generator")
+    st.write("Control which crawlers can access your site.")
+    
+    all_agents = st.checkbox("Apply to all robots (*)", value=True)
+    disallow_admin = st.checkbox("Disallow /admin", value=True)
+    disallow_private = st.checkbox("Disallow /private", value=False)
+    sitemap_url = st.text_input("Sitemap URL (Optional)", "https://yoursite.com/sitemap.xml")
+    
+    if st.button("Generate Robots.txt"):
+        agent = "*" if all_agents else "Googlebot"
+        txt = f"User-agent: {agent}\n"
+        if disallow_admin: txt += "Disallow: /admin/\n"
+        if disallow_private: txt += "Disallow: /private/\n"
+        if sitemap_url: txt += f"\nSitemap: {sitemap_url}"
+        
+        st.text_area("Result", txt, height=150)
+
+def tool_sitemap_builder():
+    st.header("🗺️ XML Sitemap Builder")
+    urls = st.text_area("Paste URLs (one per line)", "https://site.com\nhttps://site.com/about")
+    
+    if st.button("Build XML"):
+        xml = '<?xml version="1.0" encoding="UTF-8"?>\n'
+        xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+        
+        for url in urls.split('\n'):
+            if url.strip():
+                xml += f'  <url>\n    <loc>{url.strip()}</loc>\n    <changefreq>monthly</changefreq>\n  </url>\n'
+        
+        xml += '</urlset>'
+        st.text_area("Sitemap.xml", xml, height=200)
+
+def tool_keyword_density():
+    with st.spinner("Loading Analytics..."):
+        import pandas as pd
+        from collections import Counter
+    
+    
+    st.header("📊 Keyword Density Checker")
+    text = st.text_area("Paste Article Text", height=200,key="density_text")
+    
+    if st.button("Analyze"):
+        # Simple stopword list to ignore
+        stopwords = set(['the', 'and', 'is', 'in', 'it', 'of', 'to', 'a', 'for', 'on', 'that', 'with', 'as'])
+        
+        words = re.findall(r'\w+', text.lower())
+        filtered = [w for w in words if w not in stopwords and len(w) > 2]
+        
+        counts = Counter(filtered).most_common(10)
+        
+        df = pd.DataFrame(counts, columns=["Keyword", "Count"])
+        df['Density %'] = (df['Count'] / len(words) * 100).round(2)
+        st.table(df)
+
+def tool_plagiarism_check():
+    st.header("🕵️ Plagiarism Scanner (Google Check)")
+    st.info("Splits text into sentences and searches Google for exact matches.")
+    text = st.text_area("Paste Text to Check", height=150,key="plag_text")
+    
+    if st.button("Check Text"):
+        sentences = re.split(r'[.!?]', text)
+        clean_sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+        
+        for i, s in enumerate(clean_sentences[:5]): # Limit to first 5 for demo
+            query = f'"{s}"'
+            url = f"https://www.google.com/search?q={query}"
+            st.markdown(f"**Sentence {i+1}:** {s[:50]}...")
+            st.link_button(f"🔍 Check Google for Match", url)
+
+def tool_code_minifier():
+    st.header("🧹 Code Minifier")
+    mode = st.radio("Type", ["HTML", "CSS"])
+    raw_code = st.text_area("Input Code", height=200)
+    
+    if st.button("Minify"):
+        minified = ""
+        if mode == "HTML":
+            # Basic whitespace removal between tags
+            lines = raw_code.split('\n')
+            minified = "".join([line.strip() for line in lines])
+        elif mode == "CSS":
+            # Remove comments and whitespace
+            # 1. Remove comments
+            minified = re.sub(r'/\*[\s\S]*?\*/', '', raw_code)
+            # 2. Remove whitespace around braces/colons
+            minified = re.sub(r'\s*([{:;,])\s*', r'\1', minified)
+            # 3. Remove newlines
+            minified = minified.replace('\n', '').replace('\r', '')
+            
+        st.text_area("Minified Output", minified, height=200)
+# --- BATCH 3: DEVELOPER TOOLS ---
+
+def tool_qr_generator():
+    with st.spinner("Initializing QR Tool..."):
+        import qrcode
+        import io
+    
+    st.header("🏁 QR Code Generator")
+    data = st.text_input("Enter Link or Text", "https://lexicalspace.blogspot.com")
+    
+    if data:
+        qr = qrcode.QRCode(version=1, box_size=10, border=5)
+        qr.add_data(data)
+        qr.make(fit=True)
+        img = qr.make_image(fill='black', back_color='white')
+        
+        buf = io.BytesIO()
+        img.save(buf)
+        st.image(img.get_image(), width=300)
+        st.download_button("Download QR", data=buf.getvalue(), file_name="qrcode.png")
+
+def tool_json_formatter():
+    st.header("✨ JSON Prettifier")
+    raw = st.text_area("Paste Messy JSON", '{"id":1,"name":"Lexical","roles":["admin","dev"]}', height=150)
+    
+    col1, col2 = st.columns(2)
+    if col1.button("Format (Pretty)"):
+        try:
+            parsed = json.loads(raw)
+            st.code(json.dumps(parsed, indent=4), language="json")
+        except Exception as e:
+            st.error(f"Invalid JSON: {e}")
+            
+    if col2.button("Minify (Compact)"):
+        try:
+            parsed = json.loads(raw)
+            st.code(json.dumps(parsed, separators=(',', ':')), language="json")
+        except Exception as e:
+            st.error(f"Invalid JSON: {e}")
+
+def tool_base64():
+    st.header("🔐 Base64 Converter")
+    mode = st.radio("Action", ["Encode", "Decode"], horizontal=True)
+    text = st.text_area("Input Text")
+    
+    if st.button("Process"):
+        try:
+            if mode == "Encode":
+                res = base64.b64encode(text.encode()).decode()
+            else:
+                res = base64.b64decode(text).decode()
+            st.code(res)
+        except Exception as e:
+            st.error(f"Error: {e}")
+
+def tool_url_encoder():
+    st.header("🔗 URL Encoder/Decoder")
+    text = st.text_input("Input URL", "https://example.com/search?q=hello world")
+    
+    c1, c2 = st.columns(2)
+    with c1:
+        if st.button("Encode"):
+            st.code(urllib.parse.quote(text))
+    with c2:
+        if st.button("Decode"):
+            st.code(urllib.parse.unquote(text))
+
+def tool_markdown_editor():
+    st.header("📝 Markdown Editor")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        md_text = st.text_area("Write Markdown", "# Hello\n* Item 1\n* Item 2", height=400)
+    
+    with col2:
+        st.markdown("### Preview")
+        st.markdown(md_text)
+
+def tool_regex_tester():
+    st.header("🧪 Regex Tester")
+    pattern = st.text_input("Regex Pattern", r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b")
+    text = st.text_area("Test String", "Contact us at support@lexical.com or admin@site.org")
+    
+    if pattern and text:
+        try:
+            matches = re.findall(pattern, text)
+            st.write(f"Found {len(matches)} matches:")
+            st.json(matches)
+        except Exception as e:
+            st.error(f"Regex Error: {e}")
+
+def tool_uuid_gen():
+    st.header("🆔 UUID/GUID Generator")
+    count = st.number_input("How many?", 1, 100, 5)
+    
+    if st.button("Generate"):
+        uuids = [str(uuid.uuid4()) for _ in range(count)]
+        st.code("\n".join(uuids), language="text")
+
+def tool_hash_gen():
+    st.header("🔑 Hash Generator")
+    text = st.text_input("Input String", "mypassword")
+    
+    if text:
+        st.write("**MD5:**")
+        st.code(hashlib.md5(text.encode()).hexdigest())
+        st.write("**SHA256:**")
+        st.code(hashlib.sha256(text.encode()).hexdigest())
+# ... (Batch 1 & 2 Routing above) ...
+
+    # BATCH 3 ROUTING
+    elif mode == "qrcode": tool_qr_generator()
+    elif mode == "json": tool_json_formatter()
+    elif mode == "base64": tool_base64()
+    elif mode == "url": tool_url_encoder()
+    elif mode == "markdown": tool_markdown_editor()
+    elif mode == "regex": tool_regex_tester()
+    elif mode == "uuid": tool_uuid_gen()
+    elif mode == "hash": tool_hash_gen()
+
+    # ... (Home Dashboard below) ...
+        
+    st.write("### 🛠️ Developer Tools")
+    st.markdown("""
+        * [🏁 QR Code Gen](?mode=qrcode)
+        * [✨ JSON Prettifier](?mode=json)
+        * [🔐 Base64 Converter](?mode=base64)
+        * [🔗 URL Encode/Decode](?mode=url)
+        * [📝 Markdown Editor](?mode=markdown)
+        * [🧪 Regex Tester](?mode=regex)
+        * [🆔 UUID Generator](?mode=uuid)
+        * [🔑 Hash Generator](?mode=hash)
+        """)
+# --- BATCH 4: TEXT, UTILITIES & EXTRAS ---
+
+def tool_case_converter():
+    st.header("🔠 Case Converter")
+    text = st.text_area("Input Text", "hello world")
+    
+    c1, c2, c3, c4 = st.columns(4)
+    if c1.button("UPPERCASE"): st.code(text.upper(), language="text")
+    if c2.button("lowercase"): st.code(text.lower(), language="text")
+    if c3.button("Title Case"): st.code(text.title(), language="text")
+    if c4.button("aLtErNaTiNg"): 
+        res = "".join([c.upper() if i%2==0 else c.lower() for i, c in enumerate(text)])
+        st.code(res, language="text")
+
+def tool_lorem_ipsum():
+    st.header("📜 Lorem Ipsum Generator")
+    paras = st.slider("Paragraphs", 1, 10, 3)
+    
+    dummy_text = [
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+        "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+        "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.",
+        "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum.",
+        "Excepteur sint occaecat cupidatat non proident, sunt in culpa."
+    ]
+    
+    if st.button("Generate"):
+        result = "\n\n".join([random.choice(dummy_text) * 3 for _ in range(paras)])
+        st.text_area("Result", result, height=200)
+
+def tool_word_counter():
+    st.header("🧮 Word & Character Counter")
+    text = st.text_area("Paste Text Here", height=200,key="counter_text")
+    
+    if text:
+        words = len(text.split())
+        chars = len(text)
+        no_space = len(text.replace(" ", ""))
+        read_time = round(words / 200, 2)
+        
+        c1, c2, c3, c4 = st.columns(4)
+        c1.metric("Words", words)
+        c2.metric("Chars", chars)
+        c3.metric("No Spaces", no_space)
+        c4.metric("Read Time", f"{read_time} min")
+
+def tool_remove_duplicates():
+    st.header("🗑️ Remove Duplicate Lines")
+    text = st.text_area("Paste List (One per line)", "Apple\nBanana\nApple\nOrange")
+    
+    if st.button("Clean"):
+        lines = text.split('\n')
+        seen = set()
+        clean = []
+        for line in lines:
+            if line not in seen and line.strip():
+                clean.append(line)
+                seen.add(line)
+        st.text_area("Cleaned List", "\n".join(clean), height=200)
+
+def tool_text_to_speech():
+    with st.spinner("Loading Audio Engine..."):
+        from gtts import gTTS
+        import io
+    
+    st.header("🗣️ Text to Speech")
+    text = st.text_area("Enter Text", "Hello, welcome to Lexical Space.")
+    lang = st.selectbox("Language", ["en", "es", "fr", "de", "hi"],key="tts_text")
+    
+    if st.button("Speak"):
+        try:
+            tts = gTTS(text=text, lang=lang, slow=False)
+            buf = io.BytesIO()
+            tts.write_to_fp(buf)
+            st.audio(buf, format='audio/mp3')
+        except Exception as e:
+            st.error(f"Error: {e}")
+
+def tool_timestamp():
+    st.header("⏰ Unix Timestamp Converter")
+    now = int(time.time())
+    st.write(f"Current Timestamp: `{now}`")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        ts_input = st.number_input("Timestamp to Date", value=now)
+        if st.button("Convert to Date"):
+            st.success(datetime.datetime.fromtimestamp(ts_input))
+            
+    with col2:
+        d_input = st.date_input("Date to Timestamp")
+        if st.button("Convert to Timestamp"):
+            ts = int(time.mktime(d_input.timetuple()))
+            st.success(ts)
+
+def tool_color_palette():
+    st.header("🎨 Image Color Palette")
+    # ADD key="palette"
+    uploaded_file = st.file_uploader("Upload Image", type=['jpg', 'png'], key="palette")
+    
+   
+    
+    if uploaded_file:
+        img = Image.open(uploaded_file).convert("RGB")
+        st.image(img, width=200)
+        
+        # Simple extraction by resizing to 5 pixels
+        small = img.resize((5, 1))
+        colors = small.getdata()
+        
+        st.write("Dominant Colors:")
+        cols = st.columns(5)
+        for i, color in enumerate(colors):
+            hex_code = '#{:02x}{:02x}{:02x}'.format(*color)
+            cols[i].color_picker(f"Color {i+1}", hex_code, disabled=True)
+            cols[i].code(hex_code)
+
+def tool_password_strength():
+    st.header("💪 Password Strength")
+    pwd = st.text_input("Test Password", type="password")
+    
+    if pwd:
+        score = 0
+        if len(pwd) >= 8: score += 1
+        if re.search(r"[A-Z]", pwd): score += 1
+        if re.search(r"[a-z]", pwd): score += 1
+        if re.search(r"\d", pwd): score += 1
+        if re.search(r"[!@#$%^&*]", pwd): score += 1
+        
+        st.progress(score / 5)
+        if score < 3: st.warning("Weak")
+        elif score < 5: st.info("Moderate")
+        else: st.success("Strong!")
+
+def tool_aspect_ratio():
+    st.header("🖥️ Aspect Ratio Calculator")
+    w = st.number_input("Width", 1920)
+    h = st.number_input("Height", 1080)
+    
+    if w and h:
+        def gcd(a, b):
+            while b: a, b = b, a % b
+            return a
+        divisor = gcd(int(w), int(h))
+        st.metric("Aspect Ratio", f"{int(w/divisor)}:{int(h/divisor)}")
+
+def tool_stopwatch():
+    st.header("⏱️ Stopwatch")
+    if 'start_time' not in st.session_state: st.session_state.start_time = None
+    
+    if st.button("Start/Reset"):
+        st.session_state.start_time = time.time()
+        
+    if st.session_state.start_time:
+        elapsed = time.time() - st.session_state.start_time
+        st.metric("Time Elapsed", f"{elapsed:.2f}s")
+        if st.button("Stop"):
+            st.session_state.start_time = None
+
+
+def tool_python_checker():
+    st.header("🐍 Python Syntax & Error Checker")
+    st.markdown("Paste your Python code or upload a `.py` file to check for syntax errors.")
+
+    # Import dependencies inside the function to avoid global scope clutter
+    import tempfile
+    import os
+    import io
+    try:
+        from pylint.lint import Run
+        from pylint.reporters.text import TextReporter
+    except ImportError:
+        st.error("⚠️ Pylint is not installed. Please add `pylint` to your requirements.txt")
+        return
+
+    # --- INPUTS ---
+    col1, col2 = st.columns(2)
+    with col1:
+        paste_code = st.text_area("Paste Code Here", height=300)
+    with col2:
+        file_obj = st.file_uploader("Or Upload .py File", type=[".py"])
+
+    # --- PROCESS BUTTON ---
+    if st.button("Check Syntax 🚀", type="primary"):
+        code_to_check = ""
+
+        # Logic: Prefer File > Paste
+        if file_obj is not None:
+            try:
+                code_to_check = file_obj.getvalue().decode("utf-8")
+            except Exception as e:
+                st.error(f"❌ Error reading file: {str(e)}")
+                return
+        elif paste_code.strip() != "":
+            code_to_check = paste_code
+        else:
+            st.warning("⚠️ Please either paste code or upload a file.")
+            return
+
+        # --- LINTING LOGIC ---
+        # 1. Create Temp File (Pylint needs a file on disk)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".py", mode='w', encoding='utf-8') as temp:
+            temp.write(code_to_check)
+            temp_path = temp.name
+
+        # 2. Run Pylint
+        pylint_output = io.StringIO()
+        reporter = TextReporter(pylint_output)
+        
+        with st.spinner("Analyzing syntax..."):
+            try:
+                # --errors-only hides warnings, showing only code-breaking errors
+                Run([temp_path, "--errors-only"], reporter=reporter, exit=False)
+            except Exception as e:
+                st.error(f"System Error: {e}")
+
+        # 3. Cleanup & Display
+        os.unlink(temp_path) # Delete temp file
+        result = pylint_output.getvalue()
+
+        st.markdown("---")
+        if not result:
+            st.success("✅ No Syntax Errors Found! (Code looks valid)")
+            st.balloons()
+        else:
+            st.error("❌ Errors Found:")
+            # Hide the messy temp file path from the user
+            clean_report = result.replace(temp_path, "Your_Script.py")
+            st.code(clean_report, language="text")
+    
+
+# --- FINAL MAIN ROUTER (SPA VERSION) ---
+if __name__ == "__main__":
+    # 1. INITIALIZE SESSION STATE (This replaces the URL logic)
+    if 'mode' not in st.session_state:
+        st.session_state.mode = 'home'
+
+
+    # 3. NAVIGATION HANDLING
+    # Function to change mode without URL reload
+    def set_mode(new_mode):
+        st.session_state.mode = new_mode
+
+    # Show "Back to Dashboard" button if not home
+    if st.session_state.mode != 'home':
+        if st.button("⬅️ Back to Grid"):
+            set_mode('home')
+            st.rerun()
+
+    # 4. TOOL ROUTING (Checks session_state instead of URL)
+    mode = st.session_state.mode
+    
+    if mode == "youtube": tool_youtube_downloader()
+    elif mode == "smart_converter": tool_smart_converter()
+    elif mode == "compressor": tool_image_compressor()
+    elif mode == "resizer": tool_image_resizer()
+    elif mode == "thumbnail": tool_thumbnail_generator()
+    elif mode == "metatags": tool_meta_tag_generator()
+    elif mode == "slug": tool_slug_generator()
+    elif mode == "robots": tool_robots_generator()
+    elif mode == "sitemap": tool_sitemap_builder()
+    elif mode == "density": tool_keyword_density()
+    elif mode == "plagiarism": tool_plagiarism_check()
+    elif mode == "minify": tool_code_minifier()
+    elif mode == "qrcode": tool_qr_generator()
+    elif mode == "json": tool_json_formatter()
+    elif mode == "base64": tool_base64()
+    elif mode == "url": tool_url_encoder()
+    elif mode == "markdown": tool_markdown_editor()
+    elif mode == "regex": tool_regex_tester()
+    elif mode == "uuid": tool_uuid_gen()
+    elif mode == "hash": tool_hash_gen()
+    elif mode == "case": tool_case_converter()
+    elif mode == "lorem": tool_lorem_ipsum()
+    elif mode == "counter": tool_word_counter()
+    elif mode == "dedupe": tool_remove_duplicates()
+    elif mode == "tts": tool_text_to_speech()
+    elif mode == "timestamp": tool_timestamp()
+    elif mode == "palette": tool_color_palette()
+    elif mode == "password": tool_password_strength()
+    elif mode == "ratio": tool_aspect_ratio()
+    elif mode == "stopwatch": tool_stopwatch()
+    elif mode == "python": tool_python_checker()
+    elif mode == "seo": render_seo_ui()
+    elif mode == "Pdf Converter": run_ultimate_pdf_converter()
+    elif mode == "Replacer Tool": lexical_replacer_tool()
+    
+    # 5. HOME DASHBOARD (Button Grid)
+    else:
+        st.write("### ⚡ Select a tool to get started:")
+        
+        # We use standard Streamlit columns to create a grid layout
+        # This replaces the Markdown links with actual Buttons
+        
+        c1, c2 = st.columns(2)
+        
+        with c1:
+            st.info("**📂 Media & Files**")
+            if st.button("Converter"): set_mode("Replacer Tool"); st.rerun()
+            if st.button("🎥 Pdf"): set_mode("Pdf Converter"); st.rerun()
+            if st.button("🎥 YouTube Downloader"): set_mode("youtube"); st.rerun()
+            if st.button("🎥 Seo Generator"): set_mode("seo"); st.rerun()
+            
+            if st.button("🔄 Smart File Converter"): set_mode("smart_converter"); st.rerun()
+            if st.button("📉 Image Compressor"): set_mode("compressor"); st.rerun()
+            if st.button("📐 Image Resizer"): set_mode("resizer"); st.rerun()
+            if st.button("🖼️ Thumbnail Gen"): set_mode("thumbnail"); st.rerun()
+            
+            st.info("**🛠️ Developer Tools**")
+            if st.button("🏁 QR Code Gen"): set_mode("qrcode"); st.rerun()
+            if st.button("✨ JSON Prettifier"): set_mode("json"); st.rerun()
+            if st.button("🔐 Base64 Converter"): set_mode("base64"); st.rerun()
+            if st.button("🔗 URL Encoder"): set_mode("url"); st.rerun()
+            if st.button("📝 Markdown Editor"): set_mode("markdown"); st.rerun()
+            if st.button("🧪 Regex Tester"): set_mode("regex"); st.rerun()
+            if st.button("🆔 UUID Gen"): set_mode("uuid"); st.rerun()
+            if st.button("🔑 Hash Gen"): set_mode("hash"); st.rerun()
+
+        with c2:
+            st.info("**🕸️ SEO & Webmaster**")
+            if st.button("🏷️ Meta Tag Gen"): set_mode("metatags"); st.rerun()
+            if st.button("🐌 Slug Generator"): set_mode("slug"); st.rerun()
+            if st.button("🤖 Robots.txt Gen"): set_mode("robots"); st.rerun()
+            if st.button("🗺️ Sitemap Builder"): set_mode("sitemap"); st.rerun()
+            if st.button("📊 Density Checker"): set_mode("density"); st.rerun()
+            if st.button("🕵️ Plagiarism Check"): set_mode("plagiarism"); st.rerun()
+            if st.button("🧹 Code Minifier"): set_mode("minify"); st.rerun()
+
+            st.info("**📝 Text & Utilities**")
+            if st.button("🔠 Case Converter"): set_mode("case"); st.rerun()
+            if st.button("📜 Lorem Ipsum"): set_mode("lorem"); st.rerun()
+            if st.button("🧮 Word Counter"): set_mode("counter"); st.rerun()
+            if st.button("🗑️ Dedupe Lines"): set_mode("dedupe"); st.rerun()
+            if st.button("🗣️ Text to Speech"): set_mode("tts"); st.rerun()
+            if st.button("⏰ Unix Timestamp"): set_mode("timestamp"); st.rerun()
+            if st.button("🎨 Color Palette"): set_mode("palette"); st.rerun()
+            if st.button("💪 Password Strength"): set_mode("password"); st.rerun()
+            if st.button("🖥️ Aspect Ratio"): set_mode("ratio"); st.rerun()
+            if st.button("⏱️ Stopwatch"): set_mode("stopwatch"); st.rerun()
+            if st.button("Python Checker"): set_mode("python"); st.rerun()

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,11 @@
+streamlit
+requests
+Pillow
+fpdf2
+pandas
+openpyxl
+beautifulsoup4
+huggingface_hub
+qrcode
+gTTS
+pylint