Added 30 tools and requirements

app.py

@@ -1,136 +1,694 @@
 import streamlit as st
 import requests
-import json
-import time
-from PIL import Image
+import pandas as pd
+from PIL import Image, ImageDraw, ImageFont
 import io
+import time
+import json
+import base64
+import uuid
+import hashlib
+import qrcode
+import urllib.parse
+import random
+import datetime
+from gtts import gTTS
 import re
+from collections import Counter
 from bs4 import BeautifulSoup
-import markdown
-
-# --- PAGE CONFIG ---
-st.set_page_config(
-    page_title="Lexical Tools",
-    page_icon="⚡",
-    layout="centered",
-    initial_sidebar_state="expanded"
-)
-
-# --- SIDEBAR NAVIGATION ---
-st.sidebar.title("Navigation")
-query_params = st.query_params
-default_index = 1 if query_params.get("mode") == "downloader" else 0
-
-app_mode = st.sidebar.radio(
-    "Choose Tool:",
-    ["Webmaster Toolkit", "YouTube Downloader"],
-    index=default_index
-)
-
-# ==========================================
-# VIEW 1: YOUTUBE DOWNLOADER (API Version)
-# ==========================================
-if app_mode == "YouTube Downloader":
-    st.title("🎥 YouTube Media Extractor")
-    st.info("High-Speed Downloader (Powered by Cobalt API)")
-    
-    url = st.text_input("Paste YouTube URL", placeholder="https://youtube.com/watch?v=...")
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        # Cobalt supports various qualities. We'll map them simple.
-        format_type = st.radio("Format", ["Video (MP4)", "Audio Only (MP3)"])
+
+
+
+# --- BATCH 1: MEDIA & FILE FUNCTIONS ---
+
+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"):
-        status_area = st.empty()
-        status_area.info("⏳ Contacting processing server...")
+        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():
+    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'])
+    
+    if uploaded_file:
+        file_type = uploaded_file.name.split('.')[-1].lower()
         
-        try:
-            # Cobalt API Configuration
-            api_url = "https://api.cobalt.tools/api/json"
-            headers = {
-                "Accept": "application/json",
-                "Content-Type": "application/json",
-                "User-Agent": "LexicalTools/1.0"
-            }
+        # 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"])
             
-            payload = {
-                "url": url,
-                "vCodec": "h264",
-                "vQuality": "1080",
-                "aFormat": "mp3",
-                "isAudioOnly": True if "Audio" in format_type else False
-            }
-
-            # Send Request
-            response = requests.post(api_url, headers=headers, json=payload)
-            data = response.json()
-
-            if "url" in data:
-                download_link = data["url"]
-                status_area.success("✅ Media Ready!")
+            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)
                 
-                # Show a Direct Download Link (Fastest method)
-                st.link_button(f"⬇️ Click to Download {format_type}", download_link)
+                st.write("Data Preview:", df.head())
+                target_data = st.selectbox("Convert to:", ["CSV", "JSON", "Excel"])
                 
-                # Optional: Preview
-                if "Audio" not in format_type:
-                    st.video(download_link)
-                else:
-                    st.audio(download_link)
+                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"
                     
-            elif "text" in data:
-                # API returned an error message
-                st.error(f"Server Error: {data['text']}")
+                    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")
+    uploaded_file = st.file_uploader("Upload Image", type=['png', 'jpg', 'jpeg'])
+    
+    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")
+    uploaded_file = st.file_uploader("Upload Image", type=['png', 'jpg', 'jpeg', 'webp'])
+    
+    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("🖼️ Blog Thumbnail Generator")
+    uploaded_file = st.file_uploader("Background Image", type=['png', 'jpg', 'jpeg'])
+    title_text = st.text_input("Title Text", "My Awesome Post")
+    
+    if uploaded_file:
+        image = Image.open(uploaded_file).convert("RGBA")
+        
+        # Simple Overlay Logic
+        txt_img = Image.new("RGBA", image.size, (255, 255, 255, 0))
+        draw = ImageDraw.Draw(txt_img)
+        
+        # We use default font because loading system fonts on servers is risky
+        # For a real app, we would load a .ttf file included in the repo
+        # Drawing a semi-transparent black box for text readability
+        w, h = image.size
+        draw.rectangle([(0, h-100), (w, h)], fill=(0, 0, 0, 180))
+        draw.text((20, h-70), title_text, fill="white")
+        
+        final = Image.alpha_composite(image, txt_img)
+        
+        st.image(final, caption="Preview", use_column_width=True)
+        
+        if st.button("Download Thumbnail"):
+            buf = io.BytesIO()
+            final.convert("RGB").save(buf, format="JPEG")
+            st.download_button("Download", data=buf.getvalue(), file_name="thumbnail.jpg")
+
+# --- 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")
+
+    # Routing Logic
+    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()
+    else:
+        st.title("⚡ Lexical Space Tools")
+        st.write("Select a tool to get started:")
+        
+        # Dashboard Links (Batch 1)
+        st.markdown("""
+        * [🎥 YouTube Downloader](?mode=youtube)
+        * [🔄 Smart File Converter](?mode=smart_converter)
+        * [📉 Image Compressor](?mode=compressor)
+        * [📐 Image Resizer](?mode=resizer)
+        * [🖼️ Thumbnail Generator](?mode=thumbnail)
+        """)
+# --- 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():
+    st.header("📊 Keyword Density Checker")
+    text = st.text_area("Paste Article Text", height=200)
+    
+    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)
+    
+    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():
+    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:
-                st.error("Unknown error from processing server.")
+                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"Connection Error: {str(e)}")
+            st.error(f"Regex Error: {e}")
 
-# ==========================================
-# VIEW 2: WEBMASTER TOOLKIT (Existing)
-# ==========================================
-elif app_mode == "Webmaster Toolkit":
-    st.title("⚡ Webmaster's Toolkit")
+def tool_uuid_gen():
+    st.header("🆔 UUID/GUID Generator")
+    count = st.number_input("How many?", 1, 100, 5)
     
-    tab1, tab2 = st.tabs(["📝 Text Cleaner & SEO", "🖼️ Media Optimizer"])
+    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")
     
-    # --- TEXT CLEANER TAB ---
-    with tab1:
-        st.write("Paste your raw text or messy HTML below.")
-        raw_text = st.text_area("Input Text", height=200)
+    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) ...
         
-        c1, c2, c3 = st.columns(3)
-        processed_text = ""
+        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)
+    
+    if text:
+        words = len(text.split())
+        chars = len(text)
+        no_space = len(text.replace(" ", ""))
+        read_time = round(words / 200, 2)
         
-        if c1.button("Strip HTML"):
-            soup = BeautifulSoup(raw_text, "html.parser")
-            processed_text = soup.get_text(separator=" ")
-            
-        if c2.button("Fix Spacing"):
-            processed_text = re.sub(r'\s+', ' ', raw_text).strip()
+        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():
+    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"])
+    
+    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))
             
-        if c3.button("MD to HTML"):
-            processed_text = markdown.markdown(raw_text)
+    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)
 
-        if processed_text:
-            st.success("Done!")
-            st.text_area("Result", value=processed_text, height=200)
+def tool_color_palette():
+    st.header("🎨 Image Color Palette")
+    uploaded_file = st.file_uploader("Upload Image", type=['jpg', 'png'])
+    
+    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)
 
-    # --- MEDIA OPTIMIZER TAB ---
-    with tab2:
-        st.write("Convert heavy images to WebP.")
-        uploaded_file = st.file_uploader("Upload Image", type=['png', 'jpg', 'jpeg'])
+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 uploaded_file:
-            original_image = Image.open(uploaded_file)
-            st.image(original_image, caption="Original", use_column_width=True)
+    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
+# --- FINAL MAIN ROUTER ---
+if __name__ == "__main__":
+    st.set_page_config(page_title="Lexical Tools", layout="centered")
+    
+    # Hide Streamlit Style
+    st.markdown("""
+    <style>
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+    </style>
+    """, unsafe_allow_html=True)
+
+    params = st.query_params
+    mode = params.get("mode", "home")
+
+    # --- ROUTING MAP ---
+    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()
+    
+    else:
+        st.title("⚡ Lexical Space Tools")
+        st.markdown("### The Ultimate Blogger & Dev Toolkit")
+        
+        c1, c2 = st.columns(2)
+        
+        with c1:
+            st.write("**📂 Media & Files**")
+            st.write("[🎥 YouTube Downloader](?mode=youtube)")
+            st.write("[🔄 Smart Converter](?mode=smart_converter)")
+            st.write("[📉 Image Compressor](?mode=compressor)")
+            st.write("[📐 Image Resizer](?mode=resizer)")
+            st.write("[🖼️ Thumbnail Gen](?mode=thumbnail)")
             
-            if st.button("Convert to WebP"):
-                buffer = io.BytesIO()
-                original_image.save(buffer, format="WEBP", quality=80, optimize=True)
-                buffer.seek(0)
-                st.success("Converted!")
-                
-                st.download_button("Download WebP", data=buffer, file_name="image.webp")
+            st.write("**🛠️ Developer**")
+            st.write("[🏁 QR Code Gen](?mode=qrcode)")
+            st.write("[✨ JSON Prettifier](?mode=json)")
+            st.write("[🔐 Base64 Tool](?mode=base64)")
+            st.write("[🔗 URL Encode](?mode=url)")
+            st.write("[📝 Markdown Editor](?mode=markdown)")
+            st.write("[🧪 Regex Tester](?mode=regex)")
+            st.write("[🆔 UUID Gen](?mode=uuid)")
+            st.write("[🔑 Hash Gen](?mode=hash)")
+
+        with c2:
+            st.write("**🕸️ SEO & Web**")
+            st.write("[🏷️ Meta Tag Gen](?mode=metatags)")
+            st.write("[🐌 Slug Gen](?mode=slug)")
+            st.write("[🤖 Robots.txt](?mode=robots)")
+            st.write("[🗺️ Sitemap Builder](?mode=sitemap)")
+            st.write("[📊 Density Check](?mode=density)")
+            st.write("[🕵️ Plagiarism](?mode=plagiarism)")
+            st.write("[🧹 Code Minifier](?mode=minify)")
+
+            st.write("**📝 Text & Utils**")
+            st.write("[🔠 Case Converter](?mode=case)")
+            st.write("[📜 Lorem Ipsum](?mode=lorem)")
+            st.write("[🧮 Word Counter](?mode=counter)")
+            st.write("[🗑️ Dedupe Lines](?mode=dedupe)")
+            st.write("[🗣️ Text to Speech](?mode=tts)")
+            st.write("[⏰ Unix Timestamp](?mode=timestamp)")
+            st.write("[🎨 Color Palette](?mode=palette)")
+            st.write("[💪 Password Check](?mode=password)")
+            st.write("[🖥️ Aspect Ratio](?mode=ratio)")
+            st.write("[⏱️ Stopwatch](?mode=stopwatch)")

requirements.txt

@@ -1,9 +1,11 @@
 streamlit
+requests
 beautifulsoup4
 markdown
 Pillow
-fastapi
-uvicorn
-yt-dlp
-gradio
-ffmpeg-python
+pandas
+openpyxl
+pypdf
+qrcode[pil]
+gTTS
+moviepy