Update app.py

app.py

@@ -1,1208 +1,175 @@
 import io
 import re
-import streamlit as st
-import glob
 import os
+import glob
+import asyncio
+import hashlib
+import unicodedata
+import streamlit as st
 from PIL import Image
 import fitz
+import edge_tts
 from reportlab.lib.pagesizes import A4
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib import colors
 from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
-import unicodedata
-import asyncio
-import websockets
-import uuid
-from datetime import datetime
-import random
-import time
-import hashlib
-import base64
-import streamlit.components.v1 as components
-import edge_tts
-from audio_recorder_streamlit import audio_recorder
-import nest_asyncio
-import pytz
-import shutil
-import anthropic
-import openai
-from PyPDF2 import PdfReader
-import threading
-import json
-import zipfile
-from gradio_client import Client
-from dotenv import load_dotenv
-from streamlit_marquee import streamlit_marquee
-from collections import defaultdict, Counter
-import pandas as pd
-
-nest_asyncio.apply()
 
 st.set_page_config(layout="wide", initial_sidebar_state="collapsed")
 
-icons = '🤖🧠🔬📝'
-Site_Name = '🤖🧠Chat & Quote Node📝🔬'
-START_ROOM = "Sector 🌌"
-FUN_USERNAMES = {
-    "CosmicJester 🌌": "en-US-AriaNeural",
-    "PixelPanda 🐼": "en-US-JennyNeural",
-    "QuantumQuack 🦆": "en-GB-SoniaNeural",
-    "StellarSquirrel 🐿️": "en-AU-NatashaNeural",
-    "GizmoGuru ⚙️": "en-CA-ClaraNeural",
-    "NebulaNinja 🌠": "en-US-GuyNeural",
-    "ByteBuster 💾": "en-GB-RyanNeural",
-    "GalacticGopher 🌍": "en-AU-WilliamNeural",
-    "RocketRaccoon 🚀": "en-CA-LiamNeural",
-    "EchoElf 🧝": "en-US-AnaNeural",
-    "PhantomFox 🦊": "en-US-BrandonNeural",
-    "WittyWizard 🧙": "en-GB-ThomasNeural",
-    "LunarLlama 🌙": "en-AU-FreyaNeural",
-    "SolarSloth ☀️": "en-CA-LindaNeural",
-    "AstroAlpaca 🦙": "en-US-ChristopherNeural",
-    "CyberCoyote 🐺": "en-GB-ElliotNeural",
-    "MysticMoose 🦌": "en-AU-JamesNeural",
-    "GlitchGnome 🧚": "en-CA-EthanNeural",
-    "VortexViper 🐍": "en-US-AmberNeural",
-    "ChronoChimp 🐒": "en-GB-LibbyNeural"
-}
-EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values()))
-FILE_EMOJIS = {"md": "📝", "mp3": "🎵", "png": "🖼️", "mp4": "🎥", "zip": "📦"}
-
-for d in ["chat_logs", "vote_logs", "audio_logs", "history_logs", "audio_cache", "paper_metadata"]:
-    os.makedirs(d, exist_ok=True)
-
-CHAT_DIR = "chat_logs"
-VOTE_DIR = "vote_logs"
-MEDIA_DIR = "."
-AUDIO_CACHE_DIR = "audio_cache"
-AUDIO_DIR = "audio_logs"
-PAPER_DIR = "paper_metadata"
-STATE_FILE = "user_state.txt"
-
-CHAT_FILE = os.path.join(CHAT_DIR, "global_chat.md")
-QUOTE_VOTES_FILE = os.path.join(VOTE_DIR, "quote_votes.md")
-IMAGE_VOTES_FILE = os.path.join(VOTE_DIR, "image_votes.md")
-HISTORY_FILE = os.path.join(VOTE_DIR, "vote_history.md")
-
-load_dotenv()
-anthropic_key = os.getenv('ANTHROPIC_API_KEY', st.secrets.get('ANTHROPIC_API_KEY', ""))
-openai_api_key = os.getenv('OPENAI_API_KEY', st.secrets.get('OPENAI_API_KEY', ""))
-openai_client = openai.OpenAI(api_key=openai_api_key)
-
-def format_timestamp_prefix(username=""):
-    central = pytz.timezone('US/Central')
-    now = datetime.now(central)
-    return f"{now.strftime('%Y%m%d_%H%M%S')}-by-{username}"
-
-class PerformanceTimer:
-    def __init__(self, name):
-        self.name, self.start = name, None
-    def __enter__(self):
-        self.start = time.time()
-        return self
-    def __exit__(self, *args):
-        duration = time.time() - self.start
-        st.session_state['operation_timings'][self.name] = duration
-        st.session_state['performance_metrics'][self.name].append(duration)
-
-def init_session_state():
-    defaults = {
-        'server_running': False, 'server_task': None, 'active_connections': {},
-        'media_notifications': [], 'last_chat_update': 0, 'displayed_chat_lines': [],
-        'message_text': "", 'audio_cache': {}, 'pasted_image_data': None,
-        'quote_line': None, 'refresh_rate': 10, 'base64_cache': {},
-        'transcript_history': [], 'last_transcript': "", 'image_hashes': set(),
-        'tts_voice': "en-US-AriaNeural", 'chat_history': [], 'marquee_settings': {
-            "background": "#1E1E1E", "color": "#FFFFFF", "font-size": "14px",
-            "animationDuration": "20s", "width": "100%", "lineHeight": "35px"
-        }, 'operation_timings': {}, 'performance_metrics': defaultdict(list),
-        'enable_audio': True, 'download_link_cache': {}, 'username': None,
-        'autosend': True, 'autosearch': True, 'last_message': "", 'last_query': "",
-        'mp3_files': {}, 'timer_start': time.time(), 'quote_index': 0,
-        'quote_source': "famous", 'last_sent_transcript': "", 'old_val': None,
-        'last_refresh': time.time(), 'paper_metadata': {}, 'paste_image_base64': "",
-        'use_arxiv': True, 'use_arxiv_audio': False, 'speech_processed': False,
-        'auto_refresh': True
-    }
-    for k, v in defaults.items():
-        if k not in st.session_state:
-            st.session_state[k] = v
-
-def update_marquee_settings_ui():
-    st.sidebar.markdown("### 🎯 Marquee Settings")
-    cols = st.sidebar.columns(2)
-    with cols[0]:
-        st.session_state['marquee_settings']['background'] = st.color_picker("🎨 Background", "#1E1E1E")
-        st.session_state['marquee_settings']['color'] = st.color_picker("✍️ Text", "#FFFFFF")
-    with cols[1]:
-        st.session_state['marquee_settings']['font-size'] = f"{st.slider('📏 Size', 10, 24, 14)}px"
-        st.session_state['marquee_settings']['animationDuration'] = f"{st.slider('⏱️ Speed', 1, 20, 20)}s"
-
-def display_marquee(text, settings, key_suffix=""):
-    truncated = text[:280] + "..." if len(text) > 280 else text
-    streamlit_marquee(content=truncated, **settings, key=f"marquee_{key_suffix}")
-    st.write("")
-
-def clean_text_for_tts(text):
-    return re.sub(r'[#*!\[\]]+', '', ' '.join(text.split()))[:200] or "No text"
-
-def clean_text_for_filename(text):
-    return '_'.join(re.sub(r'[^\w\s-]', '', text.lower()).split())[:50]
-
-def get_high_info_terms(text, top_n=10):
-    stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with'}
-    words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
-    bi_grams = [' '.join(pair) for pair in zip(words, words[1:])]
-    filtered = [t for t in words + bi_grams if t not in stop_words and len(t.split()) <= 2]
-    return [t for t, _ in Counter(filtered).most_common(top_n)]
-
-def generate_filename(prompt, username, file_type="md", title=None):
-    timestamp = format_timestamp_prefix(username)
-    if title:
-        high_info = '-'.join(get_high_info_terms(title, 5))
-        return f"{timestamp}-{clean_text_for_filename(prompt[:20])}-{high_info}.{file_type}"
-    hash_val = hashlib.md5(prompt.encode()).hexdigest()[:8]
-    return f"{timestamp}-{hash_val}.{file_type}"
-
-def create_file(prompt, username, file_type="md", title=None):
-    filename = generate_filename(prompt, username, file_type, title)
-    with open(filename, 'w', encoding='utf-8') as f:
-        f.write(prompt)
+async def generate_audio(text, voice):
+    filename = f"{hashlib.md5(text.encode()).hexdigest()}_{voice}.mp3"
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(filename)
     return filename
 
-def get_download_link(file, file_type="mp3"):
-    cache_key = f"dl_{file}"
-    if cache_key not in st.session_state['download_link_cache']:
-        with open(file, "rb") as f:
-            b64 = base64.b64encode(f.read()).decode()
-        mime_types = {"mp3": "audio/mpeg", "png": "image/png", "mp4": "video/mp4", "md": "text/markdown", "zip": "application/zip"}
-        st.session_state['download_link_cache'][cache_key] = f'<a href="data:{mime_types.get(file_type, "application/octet-stream")};base64,{b64}" download="{os.path.basename(file)}">{FILE_EMOJIS.get(file_type, "Download")} Download {os.path.basename(file)}</a>'
-    return st.session_state['download_link_cache'][cache_key]
-
-def save_username(username):
-    try:
-        with open(STATE_FILE, 'w') as f:
-            f.write(username)
-    except Exception as e:
-        print(f"Failed to save username: {e}")
-
-def load_username():
-    if os.path.exists(STATE_FILE):
-        try:
-            with open(STATE_FILE, 'r') as f:
-                return f.read().strip()
-        except Exception as e:
-            print(f"Failed to load username: {e}")
-    return None
-
-def concatenate_markdown_files(exclude_files=["README.md"]):
-    md_files = sorted([f for f in glob.glob("*.md") if os.path.basename(f) not in exclude_files], key=os.path.getmtime)
-    all_md_content = ""
-    for i, md_file in enumerate(md_files, 1):
-        with open(md_file, 'r', encoding='utf-8') as f:
-            content = f.read().strip()
-            all_md_content += f"{i}. {content}\n"
-    return all_md_content.rstrip()
-
-def get_chat_text_only(exclude_files=["README.md"]):
-    md_files = sorted([f for f in glob.glob("*.md") if os.path.basename(f) not in exclude_files], key=os.path.getmtime)
-    chat_text = ""
-    for i, md_file in enumerate(md_files, 1):
-        with open(md_file, 'r', encoding='utf-8') as f:
-            content = f.read().strip()
-            lines = content.split('\n')
-            for line in lines:
-                if line.strip() and not line.startswith('#'):
-                    match = re.match(r'\[(.*?)\]\s(.*?)\s\((.*?)\):\s*(.*)', line)
-                    if match:
-                        message = match.group(4).strip()
-                        if message.startswith('```markdown'):
-                            message = message.replace('```markdown', '').replace('```', '').strip()
-                        chat_text += f"{message}\n"
-    return chat_text.rstrip()
-
-async def async_edge_tts_generate(text, voice, username, rate=0, pitch=0, file_format="mp3"):
-    cache_key = f"{text[:100]}_{voice}_{rate}_{pitch}_{file_format}"
-    if cache_key in st.session_state['audio_cache']:
-        return st.session_state['audio_cache'][cache_key], 0
-    start_time = time.time()
-    text = clean_text_for_tts(text)
-    if not text or text == "No text":
-        print(f"Skipping audio generation for empty/invalid text: '{text}'")
-        return None, 0
-    filename = f"{format_timestamp_prefix(username)}-{hashlib.md5(text.encode()).hexdigest()[:8]}.{file_format}"
-    try:
-        communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
-        await communicate.save(filename)
-        if os.path.exists(filename) and os.path.getsize(filename) > 0:
-            st.session_state['audio_cache'][cache_key] = filename
-            return filename, time.time() - start_time
-        else:
-            print(f"Audio file {filename} was not created or is empty.")
-            return None, 0
-    except edge_tts.exceptions.NoAudioReceived as e:
-        print(f"No audio received for text: '{text}' with voice: {voice}. Error: {e}")
-        return None, 0
-    except Exception as e:
-        print(f"Error generating audio for text: '{text}' with voice: {voice}. Error: {e}")
-        return None, 0
-
-def play_and_download_audio(file_path):
-    if file_path and os.path.exists(file_path):
-        st.audio(file_path)
-        st.markdown(get_download_link(file_path), unsafe_allow_html=True)
-    else:
-        st.warning(f"Audio file not found: {file_path}")
-
-def load_mp3_viewer():
-    mp3_files = sorted(glob.glob("*.mp3"), key=os.path.getmtime)
-    for i, mp3 in enumerate(mp3_files, 1):
-        filename = os.path.basename(mp3)
-        if filename not in st.session_state['mp3_files']:
-            st.session_state['mp3_files'][filename] = (i, mp3)
-
-async def save_chat_entry(username, message, voice, is_markdown=False):
-    if not message.strip() or message == st.session_state.last_transcript:
-        return None, None
-    central = pytz.timezone('US/Central')
-    timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-    entry = f"[{timestamp}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp}] {username} ({voice}):\n```markdown\n{message}\n```"
-    md_file = create_file(entry, username, "md")
-    with open(CHAT_FILE, 'a') as f:
-        f.write(f"{entry}\n")
-    audio_file, _ Distance = await async_edge_tts_generate(message, voice, username)
-    if audio_file:
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"[{timestamp}] {username}: Audio - {audio_file}\n")
-        st.session_state['mp3_files'][os.path.basename(audio_file)] = (len(st.session_state['chat_history']) + 1, audio_file)
-        if st.session_state.get('speech_processed', False) and st.session_state.get('message_input', '') == message:
-            st.session_state['message_input'] = ""
-            st.session_state['speech_processed'] = False
-    else:
-        st.warning(f"Failed to generate audio for: {message}")
-    await broadcast_message(f"{username}|{message}", "chat")
-    st.session_state.last_chat_update = time.time()
-    st.session_state.chat_history.append(entry)
-    st.session_state.last_transcript = message
-    return md_file, audio_file
-
-async def load_chat():
-    if not os.path.exists(CHAT_FILE):
-        with open(CHAT_FILE, 'a') as f:
-            f.write(f"# {START_ROOM} Chat\n\nWelcome to the cosmic hub! 🎤\n")
-    with open(CHAT_FILE, 'r') as f:
-        content = f.read().strip()
-    lines = content.split('\n')
-    unique_lines = list(dict.fromkeys(line for line in lines if line.strip()))
-    return unique_lines
-
-async def perform_claude_search(query, username, image=None):
-    if not query.strip() or query == st.session_state.last_transcript:
-        return None, None, None
-    client = anthropic.Anthropic(api_key=anthropic_key)
-    message_content = [{"type": "text", "text": query}]
-    if image:
-        buffered = io.BytesIO()
-        image.save(buffered, format="PNG")
-        img_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
-        message_content.append({
-            "type": "image",
-            "source": {
-                "type": "base64",
-                "media_type": "image/png",
-                "data": img_base64
-            }
-        })
-    try:
-        response = client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[{"role": "user", "content": message_content}]
-        )
-        result = response.content[0].text
-        st.markdown(f"### Claude's Reply 🧠\n{result}")
-    except Exception as e:
-        st.error(f"Claude processing failed: {e}")
-        return None, None, None
-    
-    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
-    full_text = f"Prompt: {query}\nResponse: {result}"
-    md_file, audio_file = await save_chat_entry(username, full_text, voice, True)
-    return md_file, audio_file, result
-
-async def perform_arxiv_search(query, username, claude_result=None):
-    if not query.strip() or query == st.session_state.last_transcript:
-        return None, None
-    if claude_result is None:
-        client = anthropic.Anthropic(api_key=anthropic_key)
-        claude_response = client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[{"role": "user", "content": query}]
-        )
-        claude_result = claude_response.content[0].text
-        st.markdown(f"### Claude's Reply 🧠\n{claude_result}")
-    
-    enhanced_query = f"{query}\n\n{claude_result}"
-    gradio_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    refs = gradio_client.predict(
-        enhanced_query, 10, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md"
-    )[0]
-    result = f"🔎 {enhanced_query}\n\n{refs}"
-    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
-    md_file, audio_file = await save_chat_entry(username, result, voice, True)
-    return md_file, audio_file
-
-async def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False, useArxiv=True, useArxivAudio=False):
-    start = time.time()
-    client = anthropic.Anthropic(api_key=anthropic_key)
-    response = client.messages.create(
-        model="claude-3-sonnet-20240229",
-        max_tokens=1000,
-        messages=[{"role": "user", "content": q}]
+def apply_emoji_font(text, emoji_font):
+    emoji_pattern = re.compile(
+        r"([\U0001F300-\U0001F5FF"
+        r"\U0001F600-\U0001F64F"
+        r"\U0001F680-\U0001F6FF"
+        r"\U0001F700-\U0001F77F"
+        r"\U0001F780-\U0001F7FF"
+        r"\U0001F800-\U0001F8FF"
+        r"\U0001F900-\U0001F9FF"
+        r"\U0001FA00-\U0001FA6F"
+        r"\U0001FA70-\U0001FAFF"
+        r"\u2600-\u26FF"
+        r"\u2700-\u27BF]+)"
+    )
+    def replace_emoji(match):
+        emoji = match.group(1)
+        emoji = unicodedata.normalize('NFC', emoji)
+        return f'<font face="{emoji_font}">{emoji}</font>'
+    segments = []
+    last_pos = 0
+    for match in emoji_pattern.finditer(text):
+        start, end = match.span()
+        if last_pos < start:
+            segments.append(f'<font face="DejaVuSans">{text[last_pos:start]}</font>')
+        segments.append(replace_emoji(match))
+        last_pos = end
+    if last_pos < len(text):
+        segments.append(f'<font face="DejaVuSans">{text[last_pos:]}</font>')
+    return ''.join(segments)
+
+def markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers):
+    lines = markdown_text.strip().split('\n')
+    pdf_content = []
+    number_pattern = re.compile(r'^\d+\.\s')
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('# '):
+            continue
+        if render_with_bold:
+            line = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', line)
+        if auto_bold_numbers and number_pattern.match(line):
+            if not (line.startswith("<b>") and line.endswith("</b>")):
+                line = f"<b>{line}</b>"
+        pdf_content.append(line)
+    total_lines = len(pdf_content)
+    return pdf_content, total_lines
+
+def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_numbers, enlarge_numbered, num_columns):
+    buffer = io.BytesIO()
+    page_width = A4[0] * 2
+    page_height = A4[1]
+    doc = SimpleDocTemplate(buffer, pagesize=(page_width, page_height), leftMargin=36, rightMargin=36, topMargin=36, bottomMargin=36)
+    styles = getSampleStyleSheet()
+    spacer_height = 10
+    section_spacer_height = 15
+    pdf_content, total_lines = markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers)
+    item_style = ParagraphStyle(
+        'ItemStyle', parent=styles['Normal'], fontName="DejaVuSans",
+        fontSize=base_font_size, leading=base_font_size * 1.15, spaceAfter=1
+    )
+    bold_style = ParagraphStyle(
+        'BoldStyle', parent=styles['Normal'], fontName="NotoEmoji-Bold",
+        fontSize=base_font_size, leading=base_font_size * 1.15, spaceAfter=1
+    )
+    numbered_bold_style = ParagraphStyle(
+        'NumberedBoldStyle', parent=styles['Normal'], fontName="NotoEmoji-Bold",
+        fontSize=base_font_size + 1 if enlarge_numbered else base_font_size,
+        leading=(base_font_size + 1) * 1.15 if enlarge_numbered else base_font_size * 1.15, spaceAfter=1
+    )
+    section_style = ParagraphStyle(
+        'SectionStyle', parent=styles['Heading2'], fontName="DejaVuSans",
+        textColor=colors.darkblue, fontSize=base_font_size * 1.1, leading=base_font_size * 1.32, spaceAfter=2
     )
-    st.write("Claude's reply 🧠:")
-    st.markdown(response.content[0].text)
-
-    result = response.content[0].text
-    md_file = create_file(result, "System", "md")
-    audio_file, _ = await async_edge_tts_generate(result, st.session_state['tts_voice'], "System")
-    st.subheader("📝 Main Response Audio")
-    play_and_download_audio(audio_file)
-
-    papers = []
-    if useArxiv:
-        q = q + result
-        st.write('Running Arxiv RAG with Claude inputs.')
-        gradio_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-        refs = gradio_client.predict(
-            q, 20, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md"
-        )[0]
-        papers = parse_arxiv_refs(refs, q)
-        for paper in papers:
-            filename = create_file(generate_5min_feature_markdown(paper), "System", "md", paper['title'])
-            paper['md_file'] = filename
-            st.session_state['paper_metadata'][paper['title']] = filename
-        if papers and useArxivAudio:
-            await create_paper_audio_files(papers, q)
-    elapsed = time.time() - start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-    return result, papers
-
-async def websocket_handler(websocket, path):
-    client_id = str(uuid.uuid4())
-    room_id = "chat"
-    if room_id not in st.session_state.active_connections:
-        st.session_state.active_connections[room_id] = {}
-    st.session_state.active_connections[room_id][client_id] = websocket
-    username = st.session_state.get('username', random.choice(list(FUN_USERNAMES.keys())))
-    chat_content = await load_chat()
-    if not any(f"Client-{client_id}" in line for line in chat_content):
-        await save_chat_entry("System 🌟", f"{username} has joined {START_ROOM}!", "en-US-AriaNeural")
-    try:
-        async for message in websocket:
-            if '|' in message:
-                username, content = message.split('|', 1)
-                voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
-                await save_chat_entry(username, content, voice)
-            else:
-                await websocket.send("ERROR|Message format: username|content")
-    except websockets.ConnectionClosed:
-        await save_chat_entry("System 🌟", f"{username} has left {START_ROOM}!", "en-US-AriaNeural")
-    finally:
-        if room_id in st.session_state.active_connections and client_id in st.session_state.active_connections[room_id]:
-            del st.session_state.active_connections[room_id][client_id]
-
-async def broadcast_message(message, room_id):
-    if room_id in st.session_state.active_connections:
-        disconnected = []
-        for client_id, ws in st.session_state.active_connections[room_id].items():
-            try:
-                await ws.send(message)
-            except websockets.ConnectionClosed:
-                disconnected.append(client_id)
-        for client_id in disconnected:
-            if client_id in st.session_state.active_connections[room_id]:
-                del st.session_state.active_connections[room_id][client_id]
-
-async def run_websocket_server():
-    if not st.session_state.get('server_running', False):
-        server = await websockets.serve(websocket_handler, '0.0.0.0', 8765)
-        st.session_state['server_running'] = True
-        await server.wait_closed()
-
-def start_websocket_server():
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    loop.run_until_complete(run_websocket_server())
-
-class AudioProcessor:
-    def __init__(self):
-        self.cache_dir = AUDIO_CACHE_DIR
-        os.makedirs(self.cache_dir, exist_ok=True)
-        self.metadata = json.load(open(f"{self.cache_dir}/metadata.json")) if os.path.exists(f"{self.cache_dir}/metadata.json") else {}
-
-    def _save_metadata(self):
-        with open(f"{self.cache_dir}/metadata.json", 'w') as f:
-            json.dump(self.metadata, f)
-
-    async def create_audio(self, text, voice='en-US-AriaNeural'):
-        cache_key = hashlib.md5(f"{text}:{voice}".encode()).hexdigest()
-        cache_path = f"{self.cache_dir}/{cache_key}.mp3"
-        if cache_key in self.metadata and os.path.exists(cache_path):
-            return cache_path
-        text = clean_text_for_tts(text)
-        if not text:
-            return None
-        communicate = edge_tts.Communicate(text, voice)
-        await communicate.save(cache_path)
-        self.metadata[cache_key] = {'timestamp': datetime.now().isoformat(), 'text_length': len(text), 'voice': voice}
-        self._save_metadata()
-        return cache_path
-
-def process_pdf(pdf_file, max_pages, voice, audio_processor):
-    reader = PdfReader(pdf_file)
-    total_pages = min(len(reader.pages), max_pages)
-    texts, audios = [], {}
-    async def process_page(i, text):
-        audio_path = await audio_processor.create_audio(text, voice)
-        if audio_path:
-            audios[i] = audio_path
-    for i in range(total_pages):
-        text = reader.pages[i].extract_text()
-        texts.append(text)
-        threading.Thread(target=lambda: asyncio.run(process_page(i, text))).start()
-    return texts, audios, total_pages
-
-def parse_arxiv_refs(ref_text, query):
-    if not ref_text:
-        return []
-    papers = []
-    current = {}
-    for line in ref_text.split('\n'):
-        if line.count('|') == 2:
-            if current:
-                papers.append(current)
-            date, title, *_ = line.strip('* ').split('|')
-            url = re.search(r'(https://arxiv.org/\S+)', line).group(1) if re.search(r'(https://arxiv.org/\S+)', line) else f"paper_{len(papers)}"
-            current = {'date': date, 'title': title, 'url': url, 'authors': '', 'summary': '', 'full_audio': None, 'download_base64': '', 'query': query}
-        elif current:
-            if not current['authors']:
-                current['authors'] = line.strip('* ')
-            else:
-                current['summary'] += ' ' + line.strip() if current['summary'] else line.strip()
-    if current:
-        papers.append(current)
-    return papers[:20]
-
-def generate_5min_feature_markdown(paper):
-    title, summary, authors, date, url = paper['title'], paper['summary'], paper['authors'], paper['date'], paper['url']
-    pdf_url = url.replace("abs", "pdf") + (".pdf" if not url.endswith(".pdf") else "")
-    wct, sw = len(title.split()), len(summary.split())
-    terms = get_high_info_terms(summary, 15)
-    rouge = round((len(terms) / max(sw, 1)) * 100, 2)
-    mermaid = "```mermaid\nflowchart TD\n" + "\n".join(f'    T{i+1}["{terms[i]}"] --> T{i+2}["{terms[i+1]}"]' for i in range(len(terms)-1)) + "\n```"
-    return f"""
-## 📄 {title}
-**Authors:** {authors}  
-**Date:** {date}  
-**Words:** Title: {wct}, Summary: {sw}  
-**Links:** [Abstract]({url}) | [PDF]({pdf_url})  
-**Terms:** {', '.join(terms)}  
-**ROUGE:** {rouge}%  
-### 🎤 TTF Read Aloud
-- **Title:** {title}  
-- **Terms:** {', '.join(terms)}  
-- **ROUGE:** {rouge}%  
-#### Concepts Graph
-{mermaid}
----
-"""
-
-async def create_paper_audio_files(papers, query):
-    for p in papers:
-        audio_text = clean_text_for_tts(f"{p['title']} by {p['authors']}. {p['summary']}")
-        p['full_audio'], _ = await async_edge_tts_generate(audio_text, st.session_state['tts_voice'], p['authors'])
-        if p['full_audio']:
-            p['download_base64'] = get_download_link(p['full_audio'])
-
-def save_vote(file, item, user_hash):
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    entry = f"[{timestamp}] {user_hash} voted for {item}"
-    try:
-        with open(file, 'a') as f:
-            f.write(f"{entry}\n")
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"- {timestamp} - User {user_hash} voted for {item}\n")
-        return True
-    except Exception as e:
-        print(f"Vote save flop: {e}")
-        return False
-
-def load_votes(file):
-    if not os.path.exists(file):
-        with open(file, 'w') as f:
-            f.write("# Vote Tally\n\nNo votes yet - get clicking! 🖱️\n")
-    try:
-        with open(file, 'r') as f:
-            lines = f.read().strip().split('\n')
-        votes = {}
-        for line in lines[2:]:
-            if line.strip() and 'voted for' in line:
-                item = line.split('voted for ')[1]
-                votes[item] = votes.get(item, 0) + 1
-        return votes
-    except Exception as e:
-        print(f"Vote load oopsie: {e}")
-        return {}
-
-def generate_user_hash():
-    if 'user_hash' not in st.session_state:
-        session_id = str(random.getrandbits(128))
-        hash_object = hashlib.md5(session_id.encode())
-        st.session_state['user_hash'] = hash_object.hexdigest()[:8]
-    return st.session_state['user_hash']
-
-async def save_pasted_image(image, username, prompt=""):
-    img_hash = hashlib.md5(image.tobytes()).hexdigest()[:8]
-    if img_hash in st.session_state.image_hashes:
-        return None
-    context = prompt if prompt else st.session_state.get('last_message', "pasted_image")
-    timestamp = format_timestamp_prefix(username)
-    filename = f"{timestamp}-{clean_text_for_filename(context)}-{img_hash}.png"
-    filepath = filename
-    try:
-        image.save(filepath, "PNG")
-        st.session_state.image_hashes.add(img_hash)
-        await save_chat_entry(username, f"Pasted image saved: {filepath}", FUN_USERNAMES.get(username, "en-US-AriaNeural"))
-        return filepath
-    except Exception as e:
-        st.error(f"Failed to save image: {e}")
-        return None
-
-def create_zip_of_files(files, prefix="All", query="latest"):
-    if not files:
-        return None
-    terms = get_high_info_terms(" ".join([open(f, 'r', encoding='utf-8').read() if f.endswith('.md') else os.path.splitext(os.path.basename(f))[0].replace('_', ' ') for f in files] + [query]), 5)
-    zip_name = f"{prefix}_{format_timestamp_prefix()}_{'-'.join(terms)[:20]}.zip"
-    with zipfile.ZipFile(zip_name, 'w') as z:
-        [z.write(f) for f in files]
-    return zip_name
-
-def delete_files(file_type, exclude_files=["README.md"]):
-    files = glob.glob(f"*.{file_type}")
-    if file_type == "md":
-        files = [f for f in files if os.path.basename(f) not in exclude_files]
-    for f in files:
-        try:
-            os.remove(f)
-            st.session_state['mp3_files'] = {k: v for k, v in st.session_state['mp3_files'].items() if not k.endswith(f".{file_type}")}
-        except Exception as e:
-            st.error(f"Failed to delete {f}: {e}")
-    if file_type in ["md", "mp3", "png", "mp4"]:
-        st.session_state['download_link_cache'] = {}
-
-def paste_image_component():
-    with st.form(key="paste_form"):
-        paste_input = st.text_area("Paste Image Data Here", key="paste_input", height=100)
-        submit_button = st.form_submit_button("Paste Image 📋")
-        
-        if submit_button and paste_input:
-            try:
-                if paste_input.startswith('data:image'):
-                    mime_type = paste_input.split(';')[0].split(':')[1]
-                    base64_str = paste_input.split(',')[1]
-                    img_bytes = base64.b64decode(base64_str)
-                    img = Image.open(io.BytesIO(img_bytes))
-                    st.image(img, caption=f"Pasted Image ({mime_type.split('/')[1].upper()})", use_column_width=True)
-                    return img, mime_type.split('/')[1]
-                else:
-                    st.warning("Pasted data is not a recognized image format.")
-                    return None, None
-            except Exception as e:
-                st.error(f"Error decoding pasted image: {e}")
-                return None, None
-    return None, None
-
-def create_pdf_tab(default_markdown):
-    font_files = glob.glob("*.ttf")
-    if not font_files:
-        st.error("No .ttf font files found in the current directory. Please add some, e.g., NotoEmoji-Bold.ttf and DejaVuSans.ttf.")
-        return
-    available_fonts = {os.path.splitext(os.path.basename(f))[0]: f for f in font_files}
-
-    md_files = [f for f in glob.glob("*.md") if os.path.basename(f) != "README.md"]
-    md_options = [os.path.splitext(os.path.basename(f))[0] for f in md_files]
-
-    with st.sidebar:
-        selected_md = st.selectbox("Select Markdown File", options=md_options, index=0 if md_options else -1)
-        selected_font_name = st.selectbox("Select Emoji Font", options=list(available_fonts.keys()), index=0 if "NotoEmoji-Bold" in available_fonts else 0)
-        selected_font_path = available_fonts[selected_font_name]
-        base_font_size = st.slider("Font Size (points)", min_value=6, max_value=16, value=8, step=1)
-        plain_text_mode = st.checkbox("Render as Plain Text (Preserve Bold Only)", value=False)
-        auto_bold_numbers = st.checkbox("Auto-Bold Numbered Lines", value=False)
-        enlarge_font_size = st.checkbox("Enlarge Font Size for Numbered Lines", value=True)
-        num_columns = st.selectbox("Number of Columns", options=[1, 2, 3, 4, 5, 6], index=3)
-
-        if 'markdown_content' not in st.session_state or not md_options:
-            st.session_state.markdown_content = default_markdown
-        
-        if md_options and selected_md:
-            with open(f"{selected_md}.md", "r", encoding="utf-8") as f:
-                st.session_state.markdown_content = f.read()
-
-        edited_markdown = st.text_area("Modify the markdown content below:", value=st.session_state.markdown_content, height=300, key=f"markdown_{selected_md}_{selected_font_name}_{num_columns}")
-        if st.button("Update PDF"):
-            st.session_state.markdown_content = edited_markdown
-            with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
-                f.write(edited_markdown)
-            st.rerun()
-        
-        st.download_button(label="Save Markdown", data=st.session_state.markdown_content, file_name=f"{selected_md}.md", mime="text/markdown")
-
-        st.subheader("Voice Settings")
-        voice = st.selectbox("Select Voice", options=EDGE_TTS_VOICES, index=0)
-        if st.button("Generate MP3"):
-            audio_file, _ = asyncio.run(async_edge_tts_generate(edited_markdown, voice, "System"))
-            if audio_file:
-                st.audio(audio_file)
-                st.markdown(get_download_link(audio_file), unsafe_allow_html=True)
-
-    if not md_options:
-        st.warning("No .md files found in the directory (excluding README.md). Using default content.")
-        return
-
     try:
-        pdfmetrics.registerFont(TTFont(selected_font_name, selected_font_path))
+        available_font_files = glob.glob("*.ttf")
+        if not available_font_files:
+            st.error("No .ttf font files found in the current directory.")
+            return
+        selected_font_path = None
+        for f in available_font_files:
+            if "NotoEmoji-Bold" in f:
+                selected_font_path = f
+                break
+        if selected_font_path:
+            pdfmetrics.registerFont(TTFont("NotoEmoji-Bold", selected_font_path))
         pdfmetrics.registerFont(TTFont("DejaVuSans", "DejaVuSans.ttf"))
     except Exception as e:
-        st.error(f"Failed to register fonts: {e}. Ensure both {selected_font_name}.ttf and DejaVuSans.ttf are in the directory.")
+        st.error(f"Font registration error: {e}")
         return
-
-    def apply_emoji_font(text, emoji_font):
-        emoji_pattern = re.compile(
-            r"([\U0001F300-\U0001F5FF"
-            r"\U0001F600-\U0001F64F"
-            r"\U0001F680-\U0001F6FF"
-            r"\U0001F700-\U0001F77F"
-            r"\U0001F780-\U0001F7FF"
-            r"\U0001F800-\U0001F8FF"
-            r"\U0001F900-\U0001F9FF"
-            r"\U0001FA00-\U0001FA6F"
-            r"\U0001FA70-\U0001FAFF"
-            r"\u2600-\u26FF"
-            r"\u2700-\u27BF]+)"
-        )
-
-        def replace_emoji(match):
-            emoji = match.group(1)
-            emoji = unicodedata.normalize('NFC', emoji)
-            return f'<font face="{emoji_font}">{emoji}</font>'
-
-        segments = []
-        last_pos = 0
-        for match in emoji_pattern.finditer(text):
-            start, end = match.span()
-            if last_pos < start:
-                segments.append(f'<font face="DejaVuSans">{text[last_pos:start]}</font>')
-            segments.append(replace_emoji(match))
-            last_pos = end
-        if last_pos < len(text):
-            segments.append(f'<font face="DejaVuSans">{text[last_pos:]}</font>')
-        return ''.join(segments)
-
-    def markdown_to_pdf_content(markdown_text, plain_text_mode, auto_bold_numbers):
-        lines = markdown_text.strip().split('\n')
-        pdf_content = []
-        number_pattern = re.compile(r'^\d+\.\s')
-
-        if plain_text_mode:
-            for line in lines:
-                line = line.strip()
-                if not line or line.startswith('# '):
-                    continue
-                bold_pattern = re.compile(r'\*\*(.*?)\*\*')
-                line = bold_pattern.sub(r'<b>\1</b>', line)
-                line = re.sub(r'\*\*', '', line)
-                pdf_content.append(line)
-        else:
-            for line in lines:
-                line = line.strip()
-                if not line or line.startswith('# '):
-                    continue
-                bold_pattern = re.compile(r'\*\*(.*?)\*\*')
-                if bold_pattern.search(line):
-                    line = bold_pattern.sub(r'<b>\1</b>', line)
-                    line = re.sub(r'\*\*', '', line)
-                if line.startswith('## ') or line.startswith('### '):
-                    text = line.replace('## ', '').replace('### ', '').strip()
-                    pdf_content.append(f"<b>{text}</b>")
-                elif auto_bold_numbers and number_pattern.match(line):
-                    pdf_content.append(f"<b>{line}</b>")
-                else:
-                    pdf_content.append(line.strip())
-
-        total_lines = len(pdf_content)
-        return pdf_content, total_lines
-
-    def create_pdf(markdown_text, base_font_size, plain_text_mode, num_columns, auto_bold_numbers, enlarge_font_size):
-        buffer = io.BytesIO()
-        page_width = A4[0] * 2
-        page_height = A4[1]
-        doc = SimpleDocTemplate(buffer, pagesize=(page_width, page_height), leftMargin=36, rightMargin=36, topMargin=36, bottomMargin=36)
-        styles = getSampleStyleSheet()
-        story = []
-        spacer_height = 10
-        section_spacer_height = 15
-        pdf_content, total_lines = markdown_to_pdf_content(markdown_text, plain_text_mode, auto_bold_numbers)
-
-        item_font_size = base_font_size
-        section_font_size = base_font_size * 1.1
-        numbered_font_size = base_font_size + 1 if enlarge_font_size else base_font_size
-
-        section_style = ParagraphStyle(
-            'SectionStyle', parent=styles['Heading2'], fontName="DejaVuSans",
-            textColor=colors.darkblue, fontSize=section_font_size, leading=section_font_size * 1.2, spaceAfter=2
-        )
-        item_style = ParagraphStyle(
-            'ItemStyle', parent=styles['Normal'], fontName="DejaVuSans",
-            fontSize=item_font_size, leading=item_font_size * 1.15, spaceAfter=1
-        )
-        numbered_style = ParagraphStyle(
-            'NumberedStyle', parent=styles['Normal'], fontName="DejaVuSans",
-            fontSize=numbered_font_size, leading=numbered_font_size * 1.15, spaceAfter=1
-        )
-
-        story.append(Spacer(1, spacer_height))
-        columns = [[] for _ in range(num_columns)]
-        lines_per_column = total_lines / num_columns if num_columns > 0 else total_lines
-        current_line_count = 0
-        current_column = 0
-
-        number_pattern = re.compile(r'^\d+\.\s')
-        for i, item in enumerate(pdf_content):
-            if i > 0 and number_pattern.match(item.replace('<b>', '').replace('</b>', '')):
-                columns[current_column].append(Spacer(1, section_spacer_height))
-            
-            if current_line_count >= lines_per_column and current_column < num_columns - 1:
-                current_column += 1
-                current_line_count = 0
-            columns[current_column].append(item)
-            current_line_count += 1
-
-        column_cells = [[] for _ in range(num_columns)]
-        for col_idx, column in enumerate(columns):
-            for item in column:
-                if isinstance(item, Spacer):
-                    column_cells[col_idx].append(item)
-                elif isinstance(item, str) and item.startswith('<b>'):
-                    text = item.replace('<b>', '').replace('</b>', '')
-                    column_cells[col_idx].append(Paragraph(apply_emoji_font(text, selected_font_name), section_style))
-                elif number_pattern.match(item):
-                    column_cells[col_idx].append(Paragraph(apply_emoji_font(item, selected_font_name), numbered_style))
+    columns = [[] for _ in range(num_columns)]
+    lines_per_column = total_lines / num_columns if num_columns > 0 else total_lines
+    current_line_count = 0
+    current_column = 0
+    number_pattern = re.compile(r'^\d+\.\s')
+    for item in pdf_content:
+        if current_line_count >= lines_per_column and current_column < num_columns - 1:
+            current_column += 1
+            current_line_count = 0
+        columns[current_column].append(item)
+        current_line_count += 1
+    column_cells = [[] for _ in range(num_columns)]
+    for col_idx, column in enumerate(columns):
+        for item in column:
+            if isinstance(item, str) and item.startswith("<b>") and item.endswith("</b>"):
+                content = item[3:-4].strip()
+                if number_pattern.match(content):
+                    column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), numbered_bold_style))
                 else:
-                    column_cells[col_idx].append(Paragraph(apply_emoji_font(item, selected_font_name), item_style))
-
-        max_cells = max(len(cells) for cells in column_cells) if column_cells else 0
-        for cells in column_cells:
-            cells.extend([Paragraph("", item_style)] * (max_cells - len(cells)))
-
-        col_width = (page_width - 72) / num_columns if num_columns > 0 else page_width - 72
-        table_data = list(zip(*column_cells)) if column_cells else [[]]
-        table = Table(table_data, colWidths=[col_width] * num_columns, hAlign='CENTER')
-        table.setStyle(TableStyle([
-            ('VALIGN', (0, 0), (-1, -1), 'TOP'), ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
-            ('BACKGROUND', (0, 0), (-1, -1), colors.white), ('GRID', (0, 0), (-1, -1), 0, colors.white),
-            ('LINEAFTER', (0, 0), (num_columns-1, -1), 0.5, colors.grey),
-            ('LEFTPADDING', (0, 0), (-1, -1), 2), ('RIGHTPADDING', (0, 0), (-1, -1), 2),
-            ('TOPPADDING', (0, 0), (-1, -1), 1), ('BOTTOMPADDING', (0, 0), (-1, -1), 1),
-        ]))
-
-        story.append(table)
-        doc.build(story)
-        buffer.seek(0)
-        return buffer.getvalue()
-
-    def pdf_to_image(pdf_bytes):
-        try:
-            doc = fitz.open(stream=pdf_bytes, filetype="pdf")
-            images = []
-            for page in doc:
-                pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
-                img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-                images.append(img)
-            doc.close()
-            return images
-        except Exception as e:
-            st.error(f"Failed to render PDF preview: {e}")
-            return None
-
-    with st.spinner("Generating PDF..."):
-        pdf_bytes = create_pdf(st.session_state.markdown_content, base_font_size, plain_text_mode, num_columns, auto_bold_numbers, enlarge_font_size)
-
-    with st.container():
-        pdf_images = pdf_to_image(pdf_bytes)
-        if pdf_images:
-            for img in pdf_images:
-                st.image(img, use_container_width=True)
-        else:
-            st.info("Download the PDF to view it locally.")
-
-    with st.sidebar:
-        st.download_button(label="Download PDF", data=pdf_bytes, file_name="deities_guide.pdf", mime="application/pdf")
-
-def main():
-    init_session_state()
-    load_mp3_viewer()
-    saved_username = load_username()
-    if saved_username and saved_username in FUN_USERNAMES:
-        st.session_state.username = saved_username
-    if not st.session_state.username:
-        available = [n for n in FUN_USERNAMES if not any(f"{n} has joined" in l for l in asyncio.run(load_chat()))]
-        st.session_state.username = random.choice(available or list(FUN_USERNAMES.keys()))
-        st.session_state.tts_voice = FUN_USERNAMES[st.session_state.username]
-        asyncio.run(save_chat_entry("System 🌟", f"{st.session_state.username} has joined {START_ROOM}!", "en-US-AriaNeural"))
-    save_username(st.session_state.username)
-
-    st.title(f"{Site_Name} for {st.session_state.username}")
-    update_marquee_settings_ui()
-    chat_text = get_chat_text_only()
-    display_marquee(f"🚀 Welcome to {START_ROOM} | 🤖 {st.session_state.username} | Chat: {chat_text}", st.session_state['marquee_settings'], "welcome")
-
-    mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="", key=f"speech_{st.session_state.get('speech_processed', False)}")
-    if val and val != st.session_state.last_transcript:
-        val_stripped = val.strip().replace('\n', ' ')
-        if val_stripped:
-            voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-            st.session_state['speech_processed'] = True
-            md_file, audio_file = asyncio.run(save_chat_entry(st.session_state.username, val_stripped, voice))
-            if audio_file:
-                play_and_download_audio(audio_file)
-            st.rerun()
-
-    tab_main = st.radio("Action:", ["🎤 Chat & Voice", "🔍 ArXiv", "📚 PDF to Audio", "📜 PDF Output"], horizontal=True, key="tab_main")
-    st.checkbox("Search ArXiv", key="use_arxiv")
-    st.checkbox("ArXiv Audio", key="use_arxiv_audio")
-    st.checkbox("Autosend Chat", key="autosend")
-    st.checkbox("Autosearch ArXiv", key="autosearch")
-
-    if tab_main == "🎤 Chat & Voice":
-        st.subheader(f"{START_ROOM} Chat 💬")
-        chat_content = asyncio.run(load_chat())
-        chat_container = st.container()
-        with chat_container:
-            numbered_content = "\n".join(f"{i+1}. {line}" for i, line in enumerate(chat_content))
-            st.code(numbered_content, language="python")
-
-        message = st.text_input(f"Message as {st.session_state.username}", key="message_input")
-        
-        col_paste, col_upload = st.columns(2)
-        with col_paste:
-            pasted_image, img_type = paste_image_component()
-        with col_upload:
-            uploaded_files = st.file_uploader("Upload Files", accept_multiple_files=True, type=["mp3", "png", "mp4", "md"], key="file_upload")
-        
-        if pasted_image is not None:
-            if st.session_state['paste_image_base64'] != base64.b64encode(pasted_image.tobytes()).decode('utf-8'):
-                st.session_state['paste_image_base64'] = base64.b64encode(pasted_image.tobytes()).decode('utf-8')
-                voice = FUN_USERNAMES.get(st.session_state.username, "en-USA-AriaNeural")
-                image_prompt = st.text_input("Add a prompt for Claude (e.g., 'OCR this image')", key="image_prompt", value="")
-                with st.spinner("Saving image..."):
-                    filename = asyncio.run(save_pasted_image(pasted_image, st.session_state.username, image_prompt))
-                if filename:
-                    st.success(f"Image saved as: {filename}")
-                    if image_prompt:
-                        with st.spinner("Processing with Claude..."):
-                            md_file_claude, audio_file_claude, claude_result = asyncio.run(
-                                perform_claude_search(image_prompt, st.session_state.username, pasted_image)
-                            )
-                            if audio_file_claude:
-                                play_and_download_audio(audio_file_claude)
-                            if claude_result:
-                                with st.spinner("Searching ArXiv..."):
-                                    md_file_arxiv, audio_file_arxiv = asyncio.run(
-                                        perform_arxiv_search(image_prompt, st.session_state.username, claude_result)
-                                    )
-                                    if audio_file_arxiv:
-                                        play_and_download_audio(audio_file_arxiv)
-                    st.session_state.pasted_image_data = None
-                    st.session_state['paste_image_base64'] = ""
-                    st.session_state.timer_start = time.time()
-                    save_username(st.session_state.username)
-                    st.rerun()
-
-        if uploaded_files:
-            for uploaded_file in uploaded_files:
-                file_type = uploaded_file.name.split('.')[-1].lower()
-                if file_type in ["mp3", "png", "mp4", "md"]:
-                    timestamp = format_timestamp_prefix(st.session_state.username)
-                    filename = f"{timestamp}-{clean_text_for_filename(uploaded_file.name)}"
-                    with open(filename, "wb") as f:
-                        f.write(uploaded_file.getbuffer())
-                    st.success(f"Uploaded {file_type.upper()} as: {filename}")
-                    if file_type == "png":
-                        img = Image.open(filename)
-                        st.image(img, caption=f"Uploaded Image: {filename}", use_column_width=True)
-                    elif file_type == "mp3":
-                        st.audio(filename)
-                    elif file_type == "mp4":
-                        st.video(filename)
-                    elif file_type == "md":
-                        with open(filename, 'r', encoding='utf-8') as f:
-                            st.markdown(f.read())
-                    asyncio.run(save_chat_entry(st.session_state.username, f"Uploaded {file_type.upper()}: {filename}", FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")))
-            st.session_state.timer_start = time.time()
-            save_username(st.session_state.username)
-            st.rerun()
-
-        if (message and message != st.session_state.last_message) or (st.session_state.pasted_image_data and not st.session_state['paste_image_base64']):
-            st.session_state.last_message = message
-            col_send, col_claude, col_arxiv = st.columns([1, 1, 1])
-            
-            with col_send:
-                if st.session_state.autosend or st.button("Send 🚀", key="send_button"):
-                    voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-                    if message.strip():
-                        md_file, audio_file = asyncio.run(save_chat_entry(st.session_state.username, message, voice, True))
-                        if audio_file:
-                            play_and_download_audio(audio_file)
-                    if st.session_state.pasted_image_data:
-                        asyncio.run(save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}", voice))
-                        st.session_state.pasted_image_data = None
-                    st.session_state.timer_start = time.time()
-                    save_username(st.session_state.username)
-                    st.rerun()
-
-            with col_claude:
-                if st.button("🧠 Claude", key="claude_button"):
-                    voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-                    if message.strip():
-                        md_file, audio_file, _ = asyncio.run(perform_claude_search(message, st.session_state.username))
-                        if audio_file:
-                            play_and_download_audio(audio_file)
-                        st.session_state.timer_start = time.time()
-                        save_username(st.session_state.username)
-                        st.rerun()
-
-            with col_arxiv:
-                if st.button("🔍 ArXiv", key="arxiv_button"):
-                    voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-                    if message.strip():
-                        md_file, audio_file = asyncio.run(perform_arxiv_search(message, st.session_state.username))
-                        if audio_file:
-                            play_and_download_audio(audio_file)
-                        st.session_state.timer_start = time.time()
-                        save_username(st.session_state.username)
-                        st.rerun()
-
-    elif tab_main == "🔍 ArXiv":
-        st.subheader("🔍 Query ArXiv")
-        q = st.text_input("🔍 Query:", key="arxiv_query")
-        if q and q != st.session_state.last_query:
-            st.session_state.last_query = q
-            if st.session_state.autosearch or st.button("🔍 Run", key="arxiv_run"):
-                result, papers = asyncio.run(perform_ai_lookup(q, useArxiv=st.session_state['use_arxiv'], useArxivAudio=st.session_state['use_arxiv_audio']))
-                st.markdown(f"### Query: {q}")
-                for i, p in enumerate(papers, 1):
-                    expander_label = f"{p['title']} | [arXiv Link]({p['url']})"
-                    with st.expander(expander_label):
-                        with open(p['md_file'], 'r', encoding='utf-8') as f:
-                            content = f.read()
-                        numbered_content = "\n".join(f"{j+1}. {line}" for j, line in enumerate(content.split('\n')))
-                        st.code(numbered_content, language="python")
-
-    elif tab_main == "📚 PDF to Audio":
-        audio_processor = AudioProcessor()
-        pdf_file = st.file_uploader("Choose PDF", "pdf", key="pdf_upload")
-        max_pages = st.slider('Pages', 1, 100, 10, key="pdf_pages")
-        if pdf_file:
-            with st.spinner('Processing...'):
-                texts, audios, total = process_pdf(pdf_file, max_pages, st.session_state['tts_voice'], audio_processor)
-                for i, text in enumerate(texts):
-                    with st.expander(f"Page {i+1}"):
-                        st.markdown(text)
-                        while i not in audios:
-                            time.sleep(0.1)
-                        if audios.get(i):
-                            st.audio(audios[i])
-                            st.markdown(get_download_link(audios[i], "mp3"), unsafe_allow_html=True)
-                            voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-                            asyncio.run(save_chat_entry(st.session_state.username, f"PDF Page {i+1} converted to audio: {audios[i]}", voice))
-
-    elif tab_main == "📜 PDF Output":
-        create_pdf_tab(default_markdown)
-
-    st.header("📸 Media Gallery")
-    all_files = sorted(glob.glob("*.md") + glob.glob("*.mp3") + glob.glob("*.png") + glob.glob("*.mp4"), key=os.path.getmtime)
-    md_files = [f for f in all_files if f.endswith('.md') and os.path.basename(f) != "README.md"]
-    mp3_files = [f for f in all_files if f.endswith('.mp3')]
-    png_files = [f for f in all_files if f.endswith('.png')]
-    mp4_files = [f for f in all_files if f.endswith('.mp4')]
-
-    st.subheader("All Submitted Text")
-    all_md_content = concatenate_markdown_files()
-    with st.expander("View All Markdown Content"):
-        st.markdown(all_md_content)
-
-    st.subheader("🎵 Audio (MP3)")
-    for filename, (num, mp3) in sorted(st.session_state['mp3_files'].items(), key=lambda x: x[1][0]):
-        with st.expander(f"{num}. {os.path.basename(mp3)}"):
-            st.audio(mp3)
-            st.markdown(get_download_link(mp3, "mp3"), unsafe_allow_html=True)
-
-    st.subheader("🖼️ Images (PNG)")
-    for png in sorted(png_files, key=os.path.getmtime):
-        with st.expander(os.path.basename(png)):
-            st.image(png, use_container_width=True)
-            st.markdown(get_download_link(png, "png"), unsafe_allow_html=True)
-
-    st.subheader("🎥 Videos (MP4)")
-    for mp4 in sorted(mp4_files, key=os.path.getmtime):
-        with st.expander(os.path.basename(mp4)):
-            st.video(mp4)
-            st.markdown(get_download_link(mp4, "mp4"), unsafe_allow_html=True)
-
-    st.sidebar.subheader("Voice Settings")
-    new_username = st.sidebar.selectbox("Change Name/Voice", list(FUN_USERNAMES.keys()), index=list(FUN_USERNAMES.keys()).index(st.session_state.username), key="username_select")
-    if new_username != st.session_state.username:
-        asyncio.run(save_chat_entry("System 🌟", f"{st.session_state.username} changed to {new_username}", "en-US-AriaNeural"))
-        st.session_state.username, st.session_state.tts_voice = new_username, FUN_USERNAMES[new_username]
-        st.session_state.timer_start = time.time()
-        save_username(st.session_state.username)
-        st.rerun()
-
-    st.sidebar.markdown("### 💬 Chat Dialog")
-    chat_content = asyncio.run(load_chat())
-    with st.sidebar.expander("Chat History"):
-        numbered_content = "\n".join(f"{i+1}. {line}" for i, line in enumerate(chat_content))
-        st.code(numbered_content, language="python")
-
-    st.sidebar.markdown("### 💬 Chat Text Only")
-    chat_text_only = get_chat_text_only()
-    with st.sidebar.expander("Text Only History"):
-        numbered_text = "\n".join(f"{i+1}. {line}" for i, line in enumerate(chat_text_only.split('\n')))
-        st.code(numbered_text, language="python")
-
-    st.sidebar.subheader("Vote Totals")
-    chat_votes = load_votes(QUOTE_VOTES_FILE)
-    image_votes = load_votes(IMAGE_VOTES_FILE)
-    for item, count in chat_votes.items():
-        st.sidebar.write(f"{item}: {count} votes")
-    for image, count in image_votes.items():
-        st.sidebar.write(f"{image}: {count} votes")
-
-    st.sidebar.markdown("### 📂 File History")
-    for f in all_files[:10]:
-        st.sidebar.write(f"{FILE_EMOJIS.get(f.split('.')[-1], '📄')} {os.path.basename(f)}")
-
-    st.sidebar.subheader("📦 Zip & Delete")
-    col_zip, col_del = st.sidebar.columns(2)
-    with col_zip:
-        if st.button("⬇️ Zip All", key="zip_all"):
-            zip_name = create_zip_of_files(all_files, "All")
-            if zip_name:
-                st.session_state['download_link_cache'] = {}
-        if st.button("⬇️ Zip All MD", key="zip_md"):
-            zip_name = create_zip_of_files(md_files, "MD")
-            if zip_name:
-                st.session_state['download_link_cache'] = {}
-        if st.button("⬇️ Zip All MP3", key="zip_mp3"):
-            zip_name = create_zip_of_files(mp3_files, "MP3")
-            if zip_name:
-                st.session_state['download_link_cache'] = {}
-        if st.button("⬇️ Zip All PNG", key="zip_png"):
-            zip_name = create_zip_of_files(png_files, "PNG")
-            if zip_name:
-                st.session_state['download_link_cache'] = {}
-        if st.button("⬇️ Zip All MP4", key="zip_mp4"):
-            zip_name = create_zip_of_files(mp4_files, "MP4")
-            if zip_name:
-                st.session_state['download_link_cache'] = {}
-    with col_del:
-        if st.button("🗑️ Del All", key="del_all"):
-            for ft in ["md", "mp3", "png", "mp4"]:
-                delete_files(ft)
-            st.rerun()
-        if st.button("🗑️ Del All MD", key="del_md"):
-            delete_files("md")
-            st.rerun()
-        if st.button("🗑️ Del All MP3", key="del_mp3"):
-            delete_files("mp3")
-            st.rerun()
-        if st.button("🗑️ Del All PNG", key="del_png"):
-            delete_files("png")
-            st.rerun()
-        if st.button("🗑️ Del All MP4", key="del_mp4"):
-            delete_files("mp4")
-            st.rerun()
-        if st.button("🗑️ Del All Zip", key="del_zip"):
-            delete_files("zip", exclude_files=[])
-            st.rerun()
-
-    zip_files = sorted(glob.glob("*.zip"), key=os.path.getmtime, reverse=True)
-    for zip_file in zip_files:
-        st.sidebar.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True)
-
-    st.sidebar.subheader("Set Refresh Rate ⏳")
-    st.session_state['auto_refresh'] = st.sidebar.radio("Auto Refresh", ["On", "Off"], index=0 if st.session_state['auto_refresh'] else 1) == "On"
-    st.markdown("""
-        <style>
-        .timer {
-            font-size: 24px;
-            color: #ffcc00;
-            text-align: center;
-            animation: pulse 1s infinite;
-        }
-        @keyframes pulse {
-            0% { transform: scale(1); }
-            50% { transform: scale(1.1); }
-            100% { transform: scale(1); }
-        }
-        </style>
-    """, unsafe_allow_html=True)
-
-    refresh_rate = st.sidebar.slider("Refresh Rate (seconds)", min_value=1, max_value=300, value=st.session_state.refresh_rate, step=1)
-    if refresh_rate != st.session_state.refresh_rate:
-        st.session_state.refresh_rate = refresh_rate
-        st.session_state.timer_start = time.time()
-        save_username(st.session_state.username)
-
-    col1, col2, col3 = st.sidebar.columns(3)
-    with col1:
-        if st.button("🐇 Small (1s)"):
-            st.session_state.refresh_rate = 1
-            st.session_state.timer_start = time.time()
-            save_username(st.session_state.username)
-    with col2:
-        if st.button("🐢 Medium (10s)"):
-            st.session_state.refresh_rate = 10
-            st.session_state.timer_start = time.time()
-            save_username(st.session_state.username)
-    with col3:
-        if st.button("🐘 Large (5m)"):
-            st.session_state.refresh_rate = 300
-            st.session_state.timer_start = time.time()
-            save_username(st.session_state.username)
-
-    timer_placeholder = st.sidebar.empty()
-    def update_timer():
-        start_time = st.session_state.timer_start
-        remaining_time = max(0, int(st.session_state.refresh_rate - (time.time() - start_time)))
-        timer_placeholder.markdown(f"<p class='timer'>⏳ Next refresh in: {remaining_time} seconds</p>", unsafe_allow_html=True)
-        if st.session_state['auto_refresh'] and remaining_time <= 0:
-            st.session_state.timer_start = time.time()
-            st.session_state.last_refresh = time.time()
-            st.rerun()
-
-    threading.Thread(target=lambda: [time.sleep(1) or update_timer() for _ in range(int(st.session_state.refresh_rate)+1)], daemon=True).start()
-    update_timer()
-
-    if not st.session_state.get('server_running', False) and not st.session_state.get('server_task', None):
-        st.session_state.server_task = threading.Thread(target=start_websocket_server, daemon=True)
-        st.session_state.server_task.start()
+                    column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), section_style))
+            else:
+                column_cells[col_idx].append(Paragraph(apply_emoji_font(item, "DejaVuSans"), item_style))
+    max_cells = max(len(cells) for cells in column_cells) if column_cells else 0
+    for cells in column_cells:
+        cells.extend([Paragraph("", item_style)] * (max_cells - len(cells)))
+    col_width = (page_width - 72) / num_columns if num_columns > 0 else page_width - 72
+    table_data = list(zip(*column_cells)) if column_cells else [[]]
+    table = Table(table_data, colWidths=[col_width] * num_columns, hAlign='CENTER')
+    table.setStyle(TableStyle([
+        ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('BACKGROUND', (0, 0), (-1, -1), colors.white),
+        ('GRID', (0, 0), (-1, -1), 0, colors.white),
+        ('LINEAFTER', (0, 0), (num_columns-1, -1), 0.5, colors.grey),
+        ('LEFTPADDING', (0, 0), (-1, -1), 2),
+        ('RIGHTPADDING', (0, 0), (-1, -1), 2),
+        ('TOPPADDING', (0, 0), (-1, -1), 1),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 1),
+    ]))
+    story = [Spacer(1, spacer_height), table]
+    doc.build(story)
+    buffer.seek(0)
+    return buffer.getvalue()
+
+def pdf_to_image(pdf_bytes):
+    try:
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        images = []
+        for page in doc:
+            pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            images.append(img)
+        doc.close()
+        return images
+    except Exception as e:
+        st.error(f"Failed to render PDF preview: {e}")
+        return None
 
 default_markdown = """# Deities Guide: Mythology and Moral Lessons 🌟✨
 
@@ -1381,5 +348,52 @@ default_markdown = """# Deities Guide: Mythology and Moral Lessons 🌟✨
     - **Saints/Prophets**: Virtues, e.g., justice ⚖️ and prophecy 🔮.
 """
 
-if __name__ == "__main__":
-    main()
+md_files = [f for f in glob.glob("*.md") if os.path.basename(f) != "README.md"]
+md_options = [os.path.splitext(os.path.basename(f))[0] for f in md_files]
+
+with st.sidebar:
+    st.markdown("### PDF Options")
+    selected_md = st.selectbox("Select Markdown File", options=md_options, index=0 if md_options else -1)
+    available_font_files = {os.path.splitext(os.path.basename(f))[0]: f for f in glob.glob("*.ttf")}
+    selected_font_name = st.selectbox("Select Emoji Font", options=list(available_font_files.keys()), index=list(available_font_files.keys()).index("NotoEmoji-Bold") if "NotoEmoji-Bold" in available_font_files else 0)
+    base_font_size = st.slider("Font Size (points)", min_value=6, max_value=16, value=8, step=1)
+    render_with_bold = st.checkbox("Render with Bold Formatting (remove ** markers)", value=True, key="render_with_bold")
+    auto_bold_numbers = st.checkbox("Auto Bold Numbered Lines", value=True, key="auto_bold_numbers")
+    enlarge_numbered = st.checkbox("Enlarge Font Size for Numbered Lines", value=True, key="enlarge_numbered")
+    num_columns = st.selectbox("Number of Columns", options=[1, 2, 3, 4, 5, 6], index=3)
+    if 'markdown_content' not in st.session_state or not md_options:
+        st.session_state.markdown_content = default_markdown
+    if md_options and selected_md:
+        with open(f"{selected_md}.md", "r", encoding="utf-8") as f:
+            st.session_state.markdown_content = f.read()
+    edited_markdown = st.text_area("Modify the markdown content below:", value=st.session_state.markdown_content, height=300, key=f"markdown_{selected_md}_{selected_font_name}_{num_columns}")
+    if st.button("Update PDF"):
+        st.session_state.markdown_content = edited_markdown
+        if md_options and selected_md:
+            with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
+                f.write(edited_markdown)
+        st.experimental_rerun()
+    st.download_button(label="Save Markdown", data=st.session_state.markdown_content, file_name=f"{selected_md}.md" if selected_md else "default.md", mime="text/markdown")
+    st.markdown("### Text-to-Speech")
+    VOICES = ["en-US-AriaNeural", "en-US-JennyNeural", "en-GB-SoniaNeural", "en-US-GuyNeural", "en-US-AnaNeural"]
+    selected_voice = st.selectbox("Select Voice for TTS", options=VOICES, index=0)
+    if st.button("Generate Audio"):
+        audio_file = asyncio.run(generate_audio(st.session_state.markdown_content, selected_voice))
+        st.audio(audio_file)
+        with open(audio_file, "rb") as f:
+            audio_bytes = f.read()
+        st.download_button("Download Audio", data=audio_bytes, file_name=os.path.basename(audio_file), mime="audio/mpeg")
+
+with st.spinner("Generating PDF..."):
+    pdf_bytes = create_pdf(st.session_state.markdown_content, base_font_size, render_with_bold, auto_bold_numbers, enlarge_numbered, num_columns)
+
+with st.container():
+    pdf_images = pdf_to_image(pdf_bytes)
+    if pdf_images:
+        for img in pdf_images:
+            st.image(img, use_container_width=True)
+    else:
+        st.info("Download the PDF to view it locally.")
+
+with st.sidebar:
+    st.download_button(label="Download PDF", data=pdf_bytes, file_name="output.pdf", mime="application/pdf")