diff --git "a/app.py" "b/app.py" --- "a/app.py" +++ "b/app.py" @@ -1,4 +1,4 @@ -# -*- coding: utf-8 -*- # Added for potential emoji issues in some editors +# app.py (Refactored & Consolidated - Corrected Indentation) import streamlit as st import asyncio import websockets @@ -67,8 +67,8 @@ AUDIO_DIR = "audio_logs" # World Builder Constants SAVED_WORLDS_DIR = "saved_worlds" # Directory for MD world files -PLOT_WIDTH = 50.0 # Needed for JS injection (sent to index.html) -PLOT_DEPTH = 50.0 # Needed for JS injection (sent to index.html) +PLOT_WIDTH = 50.0 # Needed for JS injection +PLOT_DEPTH = 50.0 # Needed for JS injection WORLD_STATE_FILE_MD_PREFIX = "🌍_" # Prefix for world save files # File Emojis @@ -95,14 +95,13 @@ load_dotenv() # --- Global State & Locks --- world_objects_lock = threading.Lock() -# CORRECT: This global dict persists across Streamlit reruns for the session. world_objects = defaultdict(dict) # In-memory world state {obj_id: data} -connected_clients = set() # Holds client_id strings (websocket.id) +connected_clients = set() # Holds client_id strings # ============================================================================== # Utility Functions # ============================================================================== -# ... (Keep existing utility functions: get_current_time_str, clean_filename_part, run_async, ensure_dir) ... + def get_current_time_str(tz='UTC'): """Gets formatted timestamp string in specified timezone (default UTC).""" try: @@ -115,6 +114,7 @@ def get_current_time_str(tz='UTC'): now_aware = datetime.now(pytz.utc) return now_aware.strftime('%Y%m%d_%H%M%S') + def clean_filename_part(text, max_len=30): """Cleans a string part for use in a filename.""" if not isinstance(text, str): text = "invalid_name" @@ -123,31 +123,14 @@ def clean_filename_part(text, max_len=30): return text[:max_len] def run_async(async_func, *args, **kwargs): - """Runs an async function safely from a sync context using create_task or new loop.""" + """Runs an async function safely from a sync context using create_task.""" try: loop = asyncio.get_running_loop() - # Use create_task if a loop is running (typical in async context like WebSocket handler) return loop.create_task(async_func(*args, **kwargs)) - except RuntimeError: # No running loop in this thread (typical in Streamlit's main thread) - # Run in a new event loop - suitable for fire-and-forget tasks from sync code - # Be cautious about return values here as it runs separately. - # For tasks needing results back in Streamlit, consider `asyncio.run` carefully or threading. + except RuntimeError: # No running loop in this thread # print(f"Warning: Running async func {async_func.__name__} in new event loop.") try: - # This will block the Streamlit thread until the async function completes - # return asyncio.run(async_func(*args, **kwargs)) - # For fire-and-forget, especially for broadcasts, starting a task in a managed loop is better - # Let's use create_task in a new loop if necessary for fire-and-forget - new_loop = asyncio.new_event_loop() - asyncio.set_event_loop(new_loop) - task = new_loop.create_task(async_func(*args, **kwargs)) - # Schedule loop closure? Requires more complex management. - # For simple broadcasts, maybe just let the task run. - # Consider a dedicated asyncio thread if many background tasks are needed. - # Simpler: Just run and block if needed, or use a thread if it's long. - # Let's revert to asyncio.run for simplicity, assuming functions are relatively quick. return asyncio.run(async_func(*args, **kwargs)) - except Exception as e: print(f"Error running async func {async_func.__name__} in new loop: {e}") return None @@ -156,20 +139,23 @@ def run_async(async_func, *args, **kwargs): return None def ensure_dir(dir_path): - """Creates directory if it doesn't exist.""" - os.makedirs(dir_path, exist_ok=True) + """Creates directory if it doesn't exist.""" + os.makedirs(dir_path, exist_ok=True) + +# Ensure directories exist on startup +for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR]: + ensure_dir(d) # ============================================================================== -# World State File Handling (Markdown + JSON) - CORRECT LOGIC +# World State File Handling (Markdown + JSON) # ============================================================================== def generate_world_save_filename(name="World"): """Generates a filename for saving world state MD files.""" timestamp = get_current_time_str() # Use UTC for consistency clean_name = clean_filename_part(name) - # Use uuid for better uniqueness than time-based hash - rand_id = str(uuid.uuid4())[:8] - return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_name}_{timestamp}_{rand_id}.md" + rand_hash = hashlib.md5(str(time.time()).encode() + name.encode()).hexdigest()[:6] # Seed hash + return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_name}_{timestamp}_{rand_hash}.md" def parse_world_filename(filename): """Extracts info from filename if possible, otherwise returns defaults.""" @@ -177,44 +163,37 @@ def parse_world_filename(filename): if basename.startswith(WORLD_STATE_FILE_MD_PREFIX) and basename.endswith(".md"): core_name = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3] parts = core_name.split('_') - if len(parts) >= 3: # Expecting Name_Timestamp_Hash/UUID - hash_part = parts[-1] + if len(parts) >= 3: # Expecting Name_Timestamp_Hash timestamp_str = parts[-2] - name_parts = parts[:-2]; name = "_".join(name_parts).replace('_', ' ') if name_parts else "Untitled" + name_parts = parts[:-2]; name = "_".join(name_parts) if name_parts else "Untitled" dt_obj = None try: dt_obj = datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S') dt_obj = pytz.utc.localize(dt_obj) except (ValueError, pytz.exceptions.AmbiguousTimeError, pytz.exceptions.NonExistentTimeError): dt_obj = None - return {"name": name, "timestamp": timestamp_str, "dt": dt_obj, "filename": filename, "id": hash_part} + return {"name": name.replace('_', ' '), "timestamp": timestamp_str, "dt": dt_obj, "filename": filename} - # Fallback for unknown format or direct path + # Fallback dt_fallback = None - try: - full_path = filename if os.path.exists(filename) else os.path.join(SAVED_WORLDS_DIR, filename) - if os.path.exists(full_path): - mtime = os.path.getmtime(full_path) - dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc) + try: mtime = os.path.getmtime(filename); dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc) except Exception: pass - return {"name": basename.replace('.md',''), "timestamp": "Unknown", "dt": dt_fallback, "filename": filename, "id": "N/A"} + return {"name": basename.replace('.md',''), "timestamp": "Unknown", "dt": dt_fallback, "filename": filename} def save_world_state_to_md(target_filename_base): - """Saves the current in-memory world state to a specific MD file (basename). CORRECT""" + """Saves the current in-memory world state to a specific MD file (basename).""" global world_objects save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base) print(f"Acquiring lock to save world state to: {save_path}...") success = False with world_objects_lock: - # Create a plain dict copy for serialization, locking ensures consistency world_data_dict = dict(world_objects) print(f"Saving {len(world_data_dict)} objects...") - parsed_info = parse_world_filename(save_path) # Use intended filename + parsed_info = parse_world_filename(save_path) timestamp_save = get_current_time_str() md_content = f"""# World State: {parsed_info['name']} * **File Saved:** {timestamp_save} (UTC) * **Source Timestamp:** {parsed_info['timestamp']} -* **File ID:** {parsed_info['id']} * **Objects:** {len(world_data_dict)} ```json @@ -227,65 +206,50 @@ def save_world_state_to_md(target_filename_base): success = True except Exception as e: print(f"Error saving world state to {save_path}: {e}") - st.error(f"Error saving world: {e}") return success def load_world_state_from_md(filename_base): - """Loads world state from an MD file (basename), updates global state, returns success bool. CORRECT""" + """Loads world state from an MD file (basename), updates global state, returns success bool.""" global world_objects load_path = os.path.join(SAVED_WORLDS_DIR, filename_base) - print(f"Attempting to load world state from MD file: {load_path}...") - if not os.path.exists(load_path): - st.error(f"World file not found: {filename_base}"); return False + print(f"Loading world state from MD file: {load_path}...") + if not os.path.exists(load_path): st.error(f"World file not found: {filename_base}"); return False try: with open(load_path, 'r', encoding='utf-8') as f: content = f.read() - # More robust regex to find the JSON block - json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE | re.MULTILINE) - if not json_match: - st.error(f"Could not find valid JSON block in {filename_base}"); return False + json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE) # More robust regex + if not json_match: st.error(f"Could not find valid JSON block in {filename_base}"); return False world_data_dict = json.loads(json_match.group(1)) - # Basic validation (optional but recommended) - if not isinstance(world_data_dict, dict): - raise ValueError("Loaded JSON is not a dictionary (expected format: {obj_id: data})") print(f"Acquiring lock to update world state from {filename_base}...") with world_objects_lock: - # IMPORTANT: Clear existing objects and load new ones world_objects.clear() - # Convert keys to string just in case JSON loaded them as numbers etc. - for k, v in world_data_dict.items(): - world_objects[str(k)] = v + for k, v in world_data_dict.items(): world_objects[str(k)] = v loaded_count = len(world_objects) print(f"Loaded {loaded_count} objects from {filename_base}. Lock released.") - st.session_state.current_world_file = filename_base # Track loaded file (basename) + st.session_state.current_world_file = filename_base return True except json.JSONDecodeError as e: st.error(f"Invalid JSON found in {filename_base}: {e}"); return False - except ValueError as e: st.error(f"Invalid world data format in {filename_base}: {e}"); return False except Exception as e: st.error(f"Error loading world state from {filename_base}: {e}"); st.exception(e); return False def get_saved_worlds(): - """Scans the saved worlds directory for world MD files and parses them. CORRECT""" + """Scans the saved worlds directory for world MD files and parses them.""" try: ensure_dir(SAVED_WORLDS_DIR) - # Use the specific prefix to avoid grabbing other md files world_files = glob.glob(os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")) parsed_worlds = [parse_world_filename(f) for f in world_files] - # Sort by datetime object for accuracy, handle None cases parsed_worlds.sort(key=lambda x: x['dt'] if x['dt'] else datetime.min.replace(tzinfo=pytz.utc), reverse=True) return parsed_worlds except Exception as e: - print(f"Error scanning saved worlds: {e}") - st.error(f"Could not scan saved worlds: {e}") - return [] + print(f"Error scanning saved worlds: {e}"); st.error(f"Could not scan saved worlds: {e}"); return [] # ============================================================================== # User State & Session Init # ============================================================================== -# ... (Keep existing functions: save_username, load_username, init_session_state) ... + def save_username(username): try: with open(STATE_FILE, 'w') as f: f.write(username) @@ -296,82 +260,54 @@ def load_username(): try: with open(STATE_FILE, 'r') as f: return f.read().strip() except Exception as e: print(f"Failed load username: {e}") - # Provide a default if file doesn't exist or fails to load - return list(FUN_USERNAMES.keys())[0] # Default to first fun username + return None def init_session_state(): """Initializes Streamlit session state variables.""" defaults = { - 'server_running_flag': False, 'server_instance': None, 'server_task': None, 'websocket_stop_event': None, + 'server_running_flag': False, 'server_instance': None, 'server_task': None, 'active_connections': defaultdict(dict), 'last_chat_update': 0, 'message_input': "", 'audio_cache': {}, 'tts_voice': "en-US-AriaNeural", 'chat_history': [], 'marquee_settings': {"background": "#1E1E1E", "color": "#FFFFFF", "font-size": "14px", "animationDuration": "20s", "width": "100%", "lineHeight": "35px"}, - 'enable_audio': True, 'download_link_cache': {}, - 'username': load_username(), # Load username during init - 'autosend': False, + 'enable_audio': True, 'download_link_cache': {}, 'username': None, 'autosend': False, 'last_message': "", 'timer_start': time.time(), 'last_sent_transcript': "", 'last_refresh': time.time(), 'auto_refresh': False, 'refresh_rate': 30, - 'selected_object': 'None', # Tracks the *currently selected tool* - 'initial_world_state_loaded': False, # Flag for one-time load + 'selected_object': 'None', 'initial_world_state_loaded': False, 'current_world_file': None, # Track loaded world filename (basename) 'operation_timings': {}, 'performance_metrics': defaultdict(list), 'paste_image_base64': "", 'new_world_name': "MyWorld" } for k, v in defaults.items(): if k not in st.session_state: st.session_state[k] = v - # Ensure complex types initialized correctly (redundant with defaults but safe) + # Ensure complex types initialized correctly if not isinstance(st.session_state.active_connections, defaultdict): st.session_state.active_connections = defaultdict(dict) if not isinstance(st.session_state.chat_history, list): st.session_state.chat_history = [] if not isinstance(st.session_state.marquee_settings, dict): st.session_state.marquee_settings = defaults['marquee_settings'] if not isinstance(st.session_state.audio_cache, dict): st.session_state.audio_cache = {} if not isinstance(st.session_state.download_link_cache, dict): st.session_state.download_link_cache = {} - # Set derived state like tts_voice based on loaded username - if st.session_state.username and st.session_state.username in FUN_USERNAMES: - st.session_state.tts_voice = FUN_USERNAMES[st.session_state.username] - # ============================================================================== # Audio / TTS / Chat / File Handling Helpers # ============================================================================== -# ... (Keep existing helper functions: clean_text_for_tts, create_file, get_download_link, async_edge_tts_generate, play_and_download_audio, save_chat_entry, load_chat_history, create_zip_of_files, delete_files, save_pasted_image, paste_image_component, AudioProcessor, process_pdf_tab etc.) ... -# --- These seem generally okay, focus is on the world state --- -# Example (ensure generate_filename exists or is defined if create_file uses it) -def generate_filename(prefix, username, file_type): - timestamp = get_current_time_str() - clean_user = clean_filename_part(username, 15) - clean_prefix = clean_filename_part(prefix, 20) - rand_hash = hashlib.md5(str(time.time()).encode() + prefix.encode()).hexdigest()[:6] - return f"{clean_prefix}_{clean_user}_{timestamp}_{rand_hash}.{file_type}" +# --- Text & File Helpers --- def clean_text_for_tts(text): if not isinstance(text, str): return "No text" text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text); text = re.sub(r'[#*_`!]', '', text) text = ' '.join(text.split()); return text[:250] or "No text" def create_file(content, username, file_type="md", save_path=None): - if not save_path: - # Assume a naming convention if path not given, e.g., for chat logs - prefix = content[:20] if isinstance(content, str) else 'file' - filename = generate_filename(prefix, username, file_type) - # Determine directory based on type or default - target_dir = MEDIA_DIR - if file_type == 'md' and CHAT_DIR in filename: target_dir = CHAT_DIR # Heuristic - elif file_type == 'mp3' and AUDIO_DIR in filename: target_dir = AUDIO_DIR - save_path = os.path.join(target_dir, filename) - + if not save_path: filename = generate_filename(content, username, file_type); save_path = os.path.join(MEDIA_DIR, filename) ensure_dir(os.path.dirname(save_path)) try: - mode = 'wb' if isinstance(content, bytes) else 'w' - encoding = None if mode == 'wb' else 'utf-8' - with open(save_path, mode, encoding=encoding) as f: f.write(content) - # print(f"Created file: {save_path}"); # Can be too verbose + with open(save_path, 'w', encoding='utf-8') as f: f.write(content) + # print(f"Created file: {save_path}"); # Verbose return save_path except Exception as e: print(f"Error creating file {save_path}: {e}"); return None def get_download_link(file_path, file_type="md"): - if not file_path or not os.path.exists(file_path): - basename = os.path.basename(file_path) if file_path else "N/A" - return f"Not found: {basename}" + """Generates a base64 download link for a given file.""" + if not file_path or not os.path.exists(file_path): basename = os.path.basename(file_path) if file_path else "N/A"; return f"Not found: {basename}" try: mtime = os.path.getmtime(file_path) except OSError: mtime = 0 cache_key = f"dl_{file_path}_{mtime}"; @@ -383,607 +319,348 @@ def get_download_link(file_path, file_type="md"): basename = os.path.basename(file_path) link_html = f'{FILE_EMOJIS.get(file_type, "📄")}' st.session_state.download_link_cache[cache_key] = link_html - except Exception as e: print(f"Error generating DL link for {file_path}: {e}"); return f"Err DL" + except Exception as e: print(f"Error generating DL link for {file_path}: {e}"); return f"Err" return st.session_state.download_link_cache.get(cache_key, "CacheErr") +# --- Audio / TTS --- async def async_edge_tts_generate(text, voice, username): + """Generates TTS audio using EdgeTTS and caches the result.""" if not text: return None cache_key = hashlib.md5(f"{text[:150]}_{voice}".encode()).hexdigest(); if 'audio_cache' not in st.session_state: st.session_state.audio_cache = {} cached_path = st.session_state.audio_cache.get(cache_key); if cached_path and os.path.exists(cached_path): return cached_path - text_cleaned = clean_text_for_tts(text); if not text_cleaned or text_cleaned == "No text": return None - filename_base = generate_filename(text_cleaned, username, "mp3"); save_path = os.path.join(AUDIO_DIR, filename_base); ensure_dir(AUDIO_DIR) try: communicate = edge_tts.Communicate(text_cleaned, voice); await communicate.save(save_path); if os.path.exists(save_path) and os.path.getsize(save_path) > 0: st.session_state.audio_cache[cache_key] = save_path; return save_path - else: print(f"Audio file {save_path} failed generation or is empty."); return None - except Exception as e: print(f"Edge TTS Error for '{text_cleaned[:50]}...': {e}"); return None - + else: print(f"Audio file {save_path} failed generation."); return None + except Exception as e: print(f"Edge TTS Error: {e}"); return None def play_and_download_audio(file_path): + """Displays audio player and download link in Streamlit.""" if file_path and os.path.exists(file_path): try: - st.audio(file_path, format='audio/mpeg') # Specify format - file_type = file_path.split('.')[-1].lower() - st.markdown(get_download_link(file_path, file_type), unsafe_allow_html=True) + st.audio(file_path) + file_type = file_path.split('.')[-1] + st.markdown(get_download_link(file_path, file_type), unsafe_allow_html=True) except Exception as e: st.error(f"Audio display error for {os.path.basename(file_path)}: {e}") - # else: st.caption("Audio file not available.") # Optional feedback +# --- Chat --- async def save_chat_entry(username, message, voice, is_markdown=False): - if not message or not message.strip(): return None, None + """Saves chat entry to a file and session state, generates audio.""" + if not message.strip(): return None, None timestamp_str = get_current_time_str(); - # Format entry for display - entry_display = f"**{username}** ({timestamp_str}): {message}" - # Format entry for saving to file (can be simpler) - entry_file = f"[{timestamp_str}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp_str}] {username} ({voice}):\n```markdown\n{message}\n```" - - # Generate filename based on message content for uniqueness - md_filename_base = generate_filename(message, username, "md"); - md_file_path = os.path.join(CHAT_DIR, md_filename_base); - md_file = create_file(entry_file, username, "md", save_path=md_file_path) # Save to file - - # Update live session state history (using display format) + entry = f"[{timestamp_str}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp_str}] {username} ({voice}):\n```markdown\n{message}\n```" + md_filename_base = generate_filename(message, username, "md"); md_file_path = os.path.join(CHAT_DIR, md_filename_base); + md_file = create_file(entry, username, "md", save_path=md_file_path) # Save to file if 'chat_history' not in st.session_state: st.session_state.chat_history = []; - st.session_state.chat_history.append(entry_display) # Add display format - + st.session_state.chat_history.append(entry) # Add to live history audio_file = None; if st.session_state.get('enable_audio', True): - tts_message = message # Use original message for TTS - audio_file = await async_edge_tts_generate(tts_message, voice, username) - - # Return path to saved MD file and audio file (if generated) + tts_message = message # Use original message for TTS + audio_file = await async_edge_tts_generate(tts_message, voice, username) return md_file, audio_file async def load_chat_history(): - # This function primarily loads history if session state is empty, - # otherwise it relies on the running session state. + """Loads chat history from files if session state is empty.""" if 'chat_history' not in st.session_state: st.session_state.chat_history = [] - if not st.session_state.chat_history: # Only load from files if session state is empty + if not st.session_state.chat_history: ensure_dir(CHAT_DIR) print("Loading chat history from files...") chat_files = sorted(glob.glob(os.path.join(CHAT_DIR, "*.md")), key=os.path.getmtime); loaded_count = 0 temp_history = [] for f_path in chat_files: - try: - with open(f_path, 'r', encoding='utf-8') as file: - # Attempt to parse file content back into display format (best effort) - content = file.read().strip() - match = re.match(r"\[(.*?)\] (.*?) \(.*?\): (.*)", content, re.DOTALL) - if match: - ts, user, msg = match.groups() - # Handle potential markdown blocks within the message - if "```markdown" in msg: - msg_clean = msg.split("```markdown\n")[1].split("\n```")[0] - display_entry = f"**{user}** ({ts}): \n```markdown\n{msg_clean}\n```" - else: - display_entry = f"**{user}** ({ts}): {msg}" - temp_history.append(display_entry) - loaded_count += 1 - else: - # Fallback if parsing fails, add raw content - temp_history.append(content) - loaded_count += 1 - - except Exception as e: print(f"Err read chat {f_path}: {e}") - st.session_state.chat_history = temp_history # Assign loaded history + try: + with open(f_path, 'r', encoding='utf-8') as file: temp_history.append(file.read().strip()); loaded_count += 1 + except Exception as e: print(f"Err read chat {f_path}: {e}") + st.session_state.chat_history = temp_history print(f"Loaded {loaded_count} chat entries from files.") return st.session_state.chat_history # --- File Management --- -def format_timestamp_prefix(prefix): # Helper assumed needed by save_pasted_image - return f"{prefix}_{get_current_time_str()}" - def create_zip_of_files(files_to_zip, prefix="Archive"): if not files_to_zip: st.warning("No files provided to zip."); return None - # Use a descriptive timestamp format - timestamp_str = get_current_time_str() # Format: YYYYMMDD_HHMMSS - zip_name = f"{prefix}_{timestamp_str}.zip" - zip_path = os.path.join(MEDIA_DIR, zip_name) # Save zip in base dir - ensure_dir(MEDIA_DIR) + timestamp = format_timestamp_prefix(f"Zip_{prefix}"); zip_name = f"{prefix}_{timestamp}.zip" try: - print(f"Creating zip: {zip_path}..."); - count = 0 - with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as z: + print(f"Creating zip: {zip_name}..."); + with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as z: for f in files_to_zip: - if os.path.exists(f): - z.write(f, os.path.basename(f)) # Use basename in archive - count +=1 - else: print(f"Skip zip missing: {f}") - if count > 0: - print(f"Zip success: {zip_name} ({count} files)."); st.success(f"Created {zip_name}"); return zip_path - else: - print("Zip created but no files added."); st.warning("Zip created, but no valid source files found."); os.remove(zip_path); return None + if os.path.exists(f): z.write(f, os.path.basename(f)) + else: print(f"Skip zip missing: {f}") + print("Zip success."); st.success(f"Created {zip_name}"); return zip_name except Exception as e: print(f"Zip failed: {e}"); st.error(f"Zip failed: {e}"); return None - def delete_files(file_patterns, exclude_files=None): """Deletes files matching patterns, excluding protected/specified files.""" - protected_defaults = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md", ".env"] - # Combine default protected with specific exclusions - protected = set(protected_defaults) - if exclude_files: protected.update(exclude_files) + protected = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md"] + current_world_base = st.session_state.get('current_world_file') + if current_world_base: protected.append(current_world_base) # Protect currently loaded world + if exclude_files: protected.extend(exclude_files) deleted_count = 0; errors = 0 for pattern in file_patterns: - # Ensure pattern includes the directory path correctly - # Example: os.path.join(CHAT_DIR, "*.md") - print(f"Attempting to delete files matching pattern: {pattern}") - try: - files_to_delete = glob.glob(pattern, recursive=False) # Avoid recursive unless intended - if not files_to_delete: print(f"No files found for pattern: {pattern}"); continue - - for f_path in files_to_delete: - basename = os.path.basename(f_path) - # Check if it's a file and not in the protected set - if os.path.isfile(f_path) and basename not in protected: - try: os.remove(f_path); print(f"Deleted: {f_path}"); deleted_count += 1 - except Exception as e: print(f"Failed delete {f_path}: {e}"); errors += 1 - elif os.path.isdir(f_path): print(f"Skipping directory: {f_path}") - elif basename in protected: print(f"Skipping protected file: {f_path}") - - except Exception as glob_e: print(f"Error processing pattern {pattern}: {glob_e}"); errors += 1 - + pattern_path = pattern # Assume pattern includes path from os.path.join + print(f"Attempting to delete files matching: {pattern_path}") + try: + files_to_delete = glob.glob(pattern_path) + if not files_to_delete: print(f"No files found for pattern: {pattern}"); continue + for f_path in files_to_delete: + basename = os.path.basename(f_path) + if os.path.isfile(f_path) and basename not in protected: + try: os.remove(f_path); print(f"Deleted: {f_path}"); deleted_count += 1 + except Exception as e: print(f"Failed delete {f_path}: {e}"); errors += 1 + elif os.path.isdir(f_path): print(f"Skipping directory: {f_path}") + except Exception as glob_e: print(f"Error matching pattern {pattern}: {glob_e}"); errors += 1 msg = f"Deleted {deleted_count} files."; if errors > 0: msg += f" Encountered {errors} errors."; st.warning(msg) elif deleted_count > 0: st.success(msg) - else: st.info("No matching, unprotected files found to delete.") - - # Clear caches after deletion might be relevant + else: st.info("No matching files found to delete.") st.session_state['download_link_cache'] = {}; st.session_state['audio_cache'] = {} + # --- Image Handling --- async def save_pasted_image(image, username): if not image: return None try: - # Use content hash for filename uniqueness img_hash = hashlib.md5(image.tobytes()).hexdigest()[:8]; timestamp = format_timestamp_prefix(username); filename = f"{timestamp}_pasted_{img_hash}.png"; filepath = os.path.join(MEDIA_DIR, filename) - ensure_dir(MEDIA_DIR) image.save(filepath, "PNG"); print(f"Pasted image saved: {filepath}"); return filepath except Exception as e: print(f"Failed image save: {e}"); return None def paste_image_component(): - pasted_img = None; img_type = None - # Use a unique key and provide default value - paste_input = st.text_area("Paste Image Data Here (Ctrl+V):", key="paste_input_area_widget", height=50, value="", help="Paste image data directly (e.g., from clipboard if browser supports).") - - # Check if the text area has content that looks like image data - if paste_input and paste_input.startswith('data:image'): - if st.button("Process Pasted Image 📋", key="process_paste_button"): + pasted_img = None; img_type = None + # Use a button outside the form to trigger processing the text_area value + paste_input_value = st.text_area("Paste Image Data Here", key="paste_input_area", height=50, value=st.session_state.get('paste_image_base64_input', "")) + if st.button("Process Pasted Image 📋", key="process_paste_button"): + st.session_state.paste_image_base64_input = paste_input_value # Store value when button clicked + if paste_input_value and paste_input_value.startswith('data:image'): try: - # Extract MIME type and base64 data - header, base64_str = paste_input.split(',', 1) - mime_type = header.split(';')[0].split(':')[1] - img_type = mime_type.split('/')[1] # e.g., 'png' - img_bytes = base64.b64decode(base64_str); - pasted_img = Image.open(io.BytesIO(img_bytes)); - - st.image(pasted_img, caption=f"Pasted Image ({img_type.upper()})", width=150); - # Store base64 in session state if needed elsewhere - st.session_state.paste_image_base64 = base64_str - st.success("Image processed successfully!") - # Optionally clear the text area after processing - # st.session_state.paste_input_area_widget = "" # This doesn't work directly with text_area value persistence - # Consider using streamlit_js_eval to clear the JS input if needed: - # streamlit_js_eval("document.getElementById('paste_input_area_widget').value = '';") - + mime_type = paste_input_value.split(';')[0].split(':')[1]; base64_str = paste_input_value.split(',')[1]; img_bytes = base64.b64decode(base64_str); pasted_img = Image.open(io.BytesIO(img_bytes)); img_type = mime_type.split('/')[1] + st.image(pasted_img, caption=f"Pasted ({img_type.upper()})", width=150); st.session_state.paste_image_base64 = base64_str # Store processed b64 + st.session_state.paste_image_base64_input = "" # Clear input area state + st.experimental_rerun() # Rerun to clear text area visually except ImportError: st.error("Pillow library needed for image pasting.") - except (ValueError, TypeError, IndexError) as decode_err: st.error(f"Invalid image data format: {decode_err}"); st.session_state.paste_image_base64 = "" - except Exception as e: st.error(f"Image processing error: {e}"); st.session_state.paste_image_base64 = "" - # No button shown if input doesn't look like image data - # Return the PIL image object if processed in this run - return pasted_img - -# --- PDF Processing --- Add error handling and clarity + except Exception as e: st.error(f"Img decode err: {e}"); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = "" + else: + st.warning("No valid image data pasted."); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value # Keep invalid data if user wants to edit? + + # Return the image if it was processed successfully *in the previous run* (due to rerun) + processed_b64 = st.session_state.get('paste_image_base64', '') + if processed_b64: + try: + img_bytes = base64.b64decode(processed_b64) + return Image.open(io.BytesIO(img_bytes)) + except Exception: + return None # Failed to decode stored b64 + return None + + +# --- PDF Processing --- class AudioProcessor: - def __init__(self): - self.cache_dir=AUDIO_CACHE_DIR; ensure_dir(self.cache_dir); - self.metadata_file = os.path.join(self.cache_dir, "metadata.json") - self.metadata = self._load_metadata() - - def _load_metadata(self): - try: - if os.path.exists(self.metadata_file): - with open(self.metadata_file, 'r', encoding='utf-8') as f: return json.load(f) - except (IOError, json.JSONDecodeError) as e: print(f"Warning: Could not load audio metadata: {e}") - return {} - - def _save_metadata(self): - try: - with open(self.metadata_file, 'w', encoding='utf-8') as f: json.dump(self.metadata, f, indent=2) - except IOError as e: print(f"Failed metadata save: {e}") - - async def create_audio(self, text, voice='en-US-AriaNeural'): - cache_key=hashlib.md5(f"{text[:150]}:{voice}".encode()).hexdigest(); cache_path=os.path.join(self.cache_dir, f"{cache_key}.mp3"); - - # Check cache first - if cache_key in self.metadata and os.path.exists(cache_path): - print(f"Cache hit for audio: {cache_key}"); return cache_path - - text_cleaned=clean_text_for_tts(text); - if not text_cleaned: print("Skipping TTS for empty text."); return None - - ensure_dir(os.path.dirname(cache_path)) # Ensure cache dir exists - print(f"Generating TTS for: '{text_cleaned[:50]}...' (Voice: {voice})") - try: - communicate=edge_tts.Communicate(text_cleaned, voice); await communicate.save(cache_path) - if os.path.exists(cache_path) and os.path.getsize(cache_path) > 0: - # Update metadata on successful creation - self.metadata[cache_key]={'timestamp': datetime.now().isoformat(), 'text_length': len(text_cleaned), 'voice': voice}; self._save_metadata(); - print(f"TTS success: {cache_path}") - return cache_path - else: - print(f"TTS failed: File not created or empty '{cache_path}'"); return None - except edge_tts.NoAudioReceived: print(f"TTS Error: No audio received from Edge TTS for '{text_cleaned[:50]}...'"); return None - except Exception as e: print(f"TTS Create Audio Error: {e}"); return None + def __init__(self): self.cache_dir=AUDIO_CACHE_DIR; ensure_dir(self.cache_dir); self.metadata=json.load(open(f"{self.cache_dir}/metadata.json", 'r')) if os.path.exists(f"{self.cache_dir}/metadata.json") else {} + def _save_metadata(self): + try: + with open(f"{self.cache_dir}/metadata.json", 'w') as f: json.dump(self.metadata, f, indent=2) + except Exception as e: print(f"Failed metadata save: {e}") + async def create_audio(self, text, voice='en-US-AriaNeural'): + cache_key=hashlib.md5(f"{text[:150]}:{voice}".encode()).hexdigest(); cache_path=os.path.join(self.cache_dir, f"{cache_key}.mp3"); + if cache_key in self.metadata and os.path.exists(cache_path): return cache_path + text_cleaned=clean_text_for_tts(text); + if not text_cleaned: return None + ensure_dir(os.path.dirname(cache_path)) + try: + communicate=edge_tts.Communicate(text_cleaned,voice); await communicate.save(cache_path) + if os.path.exists(cache_path) and os.path.getsize(cache_path) > 0: self.metadata[cache_key]={'timestamp': datetime.now().isoformat(), 'text_length': len(text_cleaned), 'voice': voice}; self._save_metadata(); return cache_path + else: return None + except Exception as e: print(f"TTS Create Audio Error: {e}"); return None def process_pdf_tab(pdf_file, max_pages, voice): - st.subheader("PDF Processing Results") # Change header + st.subheader("PDF Processing Results") if pdf_file is None: st.info("Upload a PDF file and click 'Process PDF' to begin."); return - - audio_processor = AudioProcessor() # Instantiate the processor + audio_processor = AudioProcessor() try: - # Use file bytes directly with PdfReader - pdf_bytes = pdf_file.getvalue() - reader = PdfReader(io.BytesIO(pdf_bytes)) + reader=PdfReader(pdf_file) + if reader.is_encrypted: st.warning("PDF is encrypted."); return + total_pages=min(len(reader.pages),max_pages); + st.write(f"Processing first {total_pages} pages of '{pdf_file.name}'...") + texts, audios={}, {}; page_threads = []; results_lock = threading.Lock() - if reader.is_encrypted: - try: - # Attempt decryption with an empty password, common for some PDFs - if reader.decrypt("") == 0: # 0 indicates failure - st.warning("PDF is encrypted and could not be decrypted with an empty password."); return - except Exception as decrypt_e: - st.warning(f"PDF is encrypted. Decryption failed: {decrypt_e}"); return - - total_pages_in_pdf = len(reader.pages) - pages_to_process = min(total_pages_in_pdf, max_pages) - st.write(f"Processing first {pages_to_process} of {total_pages_in_pdf} pages from '{pdf_file.name}'...") - - texts = {} # page_num: text - audios = {} # page_num: audio_path - page_threads = [] - results_lock = threading.Lock() # Lock for safely updating shared dicts - - # Define the target function for each thread (synchronous wrapper) + # Nested function to process each page in a thread def process_page_sync(page_num, page_text): - async def run_async_audio(): - return await audio_processor.create_audio(page_text, voice) - try: - # Run the async audio creation in the current thread's event loop (or a new one) - # asyncio.run is suitable here as each thread needs its own sync->async bridge - audio_path = asyncio.run(run_async_audio()) - if audio_path: - with results_lock: audios[page_num] = audio_path - except Exception as page_e: print(f"Error processing page {page_num+1} audio: {page_e}") - - # Extract text and start threads - extraction_errors = 0 - for i in range(pages_to_process): + async def run_async_audio(): return await audio_processor.create_audio(page_text, voice) try: - page = reader.pages[i]; text = page.extract_text(); - if text and text.strip(): - texts[i]=text; - # Start a thread only if text was extracted - thread = threading.Thread(target=process_page_sync, args=(i, text)); - page_threads.append(thread); thread.start() - else: texts[i] = "[No text extracted or page is blank]" - except Exception as extract_e: - texts[i] = f"[Error extracting text: {extract_e}]"; print(f"Error extracting text from page {i+1}: {extract_e}"); extraction_errors += 1 - - if extraction_errors > 0: st.warning(f"Encountered errors extracting text from {extraction_errors} pages.") + # Using asyncio.run here is simpler in thread context than managing loops explicitly + audio_path = asyncio.run(run_async_audio()) + if audio_path: + with results_lock: audios[page_num] = audio_path + except Exception as page_e: print(f"Err process page {page_num+1}: {page_e}") + + # Start threads + for i in range(total_pages): + try: + page = reader.pages[i]; text = page.extract_text(); + if text and text.strip(): texts[i]=text; thread = threading.Thread(target=process_page_sync, args=(i, text)); page_threads.append(thread); thread.start() + else: texts[i] = "[No text extracted or page empty]" + except Exception as extract_e: texts[i] = f"[Error extract: {extract_e}]"; print(f"Error page {i+1} extract: {extract_e}") # Wait for threads and display progress - progress_bar = st.progress(0.0, text="Generating audio for extracted pages...") + progress_bar = st.progress(0.0, text="Processing pages...") total_threads = len(page_threads) start_join_time = time.time() - processed_count = 0 - if total_threads > 0: - while processed_count < total_threads: - processed_count = total_threads - sum(t.is_alive() for t in page_threads) - progress = processed_count / total_threads - progress_bar.progress(min(progress, 1.0), text=f"Audio generated for {processed_count}/{total_threads} pages...") - if time.time() - start_join_time > 600: # 10 min timeout - print("PDF audio processing timed out joining threads."); st.warning("Audio generation timed out."); break - time.sleep(0.5) # Reduce busy-waiting - progress_bar.progress(1.0, text="Audio generation complete.") - - # Display results sequentially - st.write("---") - st.subheader("Processed Content:") - for i in range(pages_to_process): - with st.expander(f"Page {i+1}"): - page_text = texts.get(i, "[Error retrieving text]") - st.markdown(f"**Text:**\n```\n{page_text}\n```" if not page_text.startswith("[") else page_text) # Show text in code block - st.markdown("---") - st.markdown("**Audio:**") - audio_file = audios.get(i) - if audio_file: play_and_download_audio(audio_file) - else: st.caption("Audio not generated or generation failed.") - - except Exception as pdf_e: st.error(f"Error reading or processing PDF '{pdf_file.name}': {pdf_e}"); st.exception(pdf_e) + while any(t.is_alive() for t in page_threads): + completed_threads = total_threads - sum(t.is_alive() for t in page_threads) + progress = completed_threads / total_threads if total_threads > 0 else 1.0 + progress_bar.progress(min(progress, 1.0), text=f"Processed {completed_threads}/{total_threads} pages...") + if time.time() - start_join_time > 600: print("PDF processing timed out."); break # 10 min timeout + time.sleep(0.5) + progress_bar.progress(1.0, text="Processing complete.") + + # Display results + st.write("Displaying results:") + for i in range(total_pages): + with st.expander(f"Page {i+1}"): + st.markdown(texts.get(i, "[Error getting text]")) + audio_file = audios.get(i) + if audio_file: play_and_download_audio(audio_file) + else: st.caption("Audio generation failed or was skipped.") + + except Exception as pdf_e: st.error(f"Err read PDF: {pdf_e}"); st.exception(pdf_e) # ============================================================================== -# WebSocket Server Logic - CORRECT LOGIC FOR STATE SYNC +# WebSocket Server Logic # ============================================================================== async def register_client(websocket): - """Adds client to tracking sets/dicts.""" - client_id = str(websocket.id); - connected_clients.add(client_id); - # Ensure active_connections dict exists in session state + client_id = str(websocket.id); connected_clients.add(client_id); if 'active_connections' not in st.session_state: st.session_state.active_connections = defaultdict(dict); - st.session_state.active_connections[client_id] = websocket; - print(f"Client registered: {client_id}. Total clients: {len(connected_clients)}") + st.session_state.active_connections[client_id] = websocket; print(f"Client registered: {client_id}. Total: {len(connected_clients)}") async def unregister_client(websocket): - """Removes client from tracking sets/dicts.""" - client_id = str(websocket.id); - connected_clients.discard(client_id); - # Safely remove from session state dict + client_id = str(websocket.id); connected_clients.discard(client_id); if 'active_connections' in st.session_state: st.session_state.active_connections.pop(client_id, None); - print(f"Client unregistered: {client_id}. Remaining clients: {len(connected_clients)}") + print(f"Client unregistered: {client_id}. Remaining: {len(connected_clients)}") async def send_safely(websocket, message, client_id): - """Sends a message to a single client with error handling.""" - try: - await websocket.send(message) - # print(f"Sent message to {client_id}: {message[:100]}...") # Verbose - return True - except websockets.ConnectionClosed: print(f"WS Send failed (ConnectionClosed) for client {client_id}"); return False - except RuntimeError as e: print(f"WS Send failed (RuntimeError: {e}) for client {client_id}"); return False - except Exception as e: print(f"WS Send failed (Other: {e}) for client {client_id}"); return False + """Wrapper to send message and handle potential connection errors.""" + try: await websocket.send(message) + except websockets.ConnectionClosed: print(f"WS Send failed (Closed) client {client_id}"); raise + except RuntimeError as e: print(f"WS Send failed (Runtime {e}) client {client_id}"); raise + except Exception as e: print(f"WS Send failed (Other {e}) client {client_id}"); raise async def broadcast_message(message, exclude_id=None): - """Broadcasts a message to all connected clients except the excluded one.""" - if not connected_clients: return # No clients to broadcast to - - # Create tasks for sending concurrently - # Use copies of the sets/dicts to avoid issues if they change during iteration - active_connections_copy = st.session_state.get('active_connections', {}).copy() - tasks = [] - # print(f"Broadcasting message (exclude {exclude_id}): {message[:100]}...") # Verbose - for client_id, websocket in active_connections_copy.items(): - if client_id == exclude_id: continue # Skip the excluded client - # Check if websocket object seems valid (basic check) - if websocket and websocket.open: - tasks.append(send_safely(websocket, message, client_id)) - else: - print(f"Skipping broadcast to inactive/invalid websocket for client {client_id}") - # Optionally: Clean up inactive connections here or periodically - connected_clients.discard(client_id) # Remove from main set - st.session_state.active_connections.pop(client_id, None) - - - if tasks: - results = await asyncio.gather(*tasks, return_exceptions=True) - # Optional: Log results or handle failures - success_count = sum(1 for r in results if isinstance(r, bool) and r) - fail_count = len(tasks) - success_count - # print(f"Broadcast complete: {success_count} success, {fail_count} failures.") # Verbose - # else: print("No active clients to broadcast to.") # Verbose + """Sends a message to all connected clients except the excluded one.""" + if not connected_clients: return + tasks = []; current_client_ids = list(connected_clients); active_connections_copy = st.session_state.active_connections.copy() + for client_id in current_client_ids: + if client_id == exclude_id: continue + websocket = active_connections_copy.get(client_id) + if websocket: tasks.append(asyncio.create_task(send_safely(websocket, message, client_id))) + if tasks: await asyncio.gather(*tasks, return_exceptions=True) # Gather results/exceptions async def broadcast_world_update(): - """Sends the entire current world state to ALL connected clients. CORRECT for sync.""" - with world_objects_lock: - # Ensure payload is serializable (convert defaultdict to dict) - current_state_payload = dict(world_objects) + """Broadcasts the current world state to all clients.""" + with world_objects_lock: current_state_payload = dict(world_objects) update_msg = json.dumps({"type": "initial_state", "payload": current_state_payload}) - object_count = len(current_state_payload) - print(f"Broadcasting full world update ({object_count} objects) to all clients...") - # Send to ALL clients, as this often follows a load operation affecting everyone - await broadcast_message(update_msg) # No exclude_id needed here - + print(f"Broadcasting full world update ({len(current_state_payload)} objects)...") + await broadcast_message(update_msg) async def websocket_handler(websocket, path): - """Handles incoming WebSocket connections and messages. CORRECT""" - client_id = str(websocket.id) # Use websocket's built-in unique ID - await register_client(websocket) - # Determine username - use session state default or fallback + """Handles WebSocket connections and messages.""" + await register_client(websocket); client_id = str(websocket.id); username = st.session_state.get('username', f"User_{client_id[:4]}") - print(f"WebSocket connection established for {client_id} ({username}) from {websocket.remote_address}") - - try: - # 1. Send Initial State - CRITICAL for client sync on connect/reconnect + try: # Send initial state with world_objects_lock: initial_state_payload = dict(world_objects) - initial_state_msg = json.dumps({"type": "initial_state", "payload": initial_state_payload}) - if await send_safely(websocket, initial_state_msg, client_id): - print(f"Sent initial state ({len(initial_state_payload)} objs) to {client_id}") - else: raise websockets.ConnectionClosed # Failed to send initial state, abort + initial_state_msg = json.dumps({"type": "initial_state", "payload": initial_state_payload}); await websocket.send(initial_state_msg) + print(f"Sent initial state ({len(initial_state_payload)} objs) to {client_id}") + await broadcast_message(json.dumps({"type": "user_join", "payload": {"username": username, "id": client_id}}), exclude_id=client_id) + except Exception as e: print(f"Error initial phase {client_id}: {e}") - # 2. Announce User Join to others - join_msg = json.dumps({"type": "user_join", "payload": {"username": username, "id": client_id}}) - await broadcast_message(join_msg, exclude_id=client_id) - - # 3. Message Processing Loop + try: # Message loop async for message in websocket: - # print(f"Received message from {client_id}: {message[:150]}...") # Verbose try: data = json.loads(message); msg_type = data.get("type"); payload = data.get("payload", {}); - # Use payload's username if provided (e.g., from client input), else fallback - sender_username = payload.get("username", username) # Prefer payload username + sender_username = payload.get("username", username) - # --- Handle Different Message Types --- if msg_type == "chat_message": - chat_text = payload.get('message', ''); - # Use voice associated with sender_username from FUN_USERNAMES map - voice = FUN_USERNAMES.get(sender_username, EDGE_TTS_VOICES[0]) # Fallback voice - if chat_text: - # Save locally (creates file, adds to session history, generates TTS async) - run_async(save_chat_entry, sender_username, chat_text, voice) - # Broadcast the original message so other clients update their chat UI - await broadcast_message(message, exclude_id=client_id) + chat_text = payload.get('message', ''); voice = payload.get('voice', FUN_USERNAMES.get(sender_username, "en-US-AriaNeural")); + run_async(save_chat_entry, sender_username, chat_text, voice) # Fire-and-forget save + await broadcast_message(message, exclude_id=client_id) # Forward original msg elif msg_type == "place_object": obj_data = payload.get("object_data"); - # Validate required fields - if obj_data and 'obj_id' in obj_data and 'type' in obj_data and 'position' in obj_data: - obj_id = str(obj_data['obj_id']) # Ensure key is string - with world_objects_lock: world_objects[obj_id] = obj_data - # Broadcast that an object was placed (incl. who placed it) + if obj_data and 'obj_id' in obj_data and 'type' in obj_data: + with world_objects_lock: world_objects[obj_data['obj_id']] = obj_data broadcast_payload = json.dumps({"type": "object_placed", "payload": {"object_data": obj_data, "username": sender_username}}); - await broadcast_message(broadcast_payload) # Send to ALL including sender for confirmation/sync - print(f"Object placed by {sender_username}: {obj_id} ({obj_data.get('type')})") - else: print(f"WS Warning: Invalid place_object payload received from {client_id}: {payload}") + await broadcast_message(broadcast_payload, exclude_id=client_id) + else: print(f"WS Invalid place_object payload: {payload}") elif msg_type == "delete_object": - obj_id = payload.get("obj_id"); removed = False - if obj_id: - obj_id = str(obj_id) # Ensure key is string - with world_objects_lock: - if obj_id in world_objects: - del world_objects[obj_id]; removed = True - if removed: - # Broadcast that an object was deleted (incl. who deleted it) - broadcast_payload = json.dumps({"type": "object_deleted", "payload": {"obj_id": obj_id, "username": sender_username}}); - await broadcast_message(broadcast_payload) # Send to ALL for sync - print(f"Object deleted by {sender_username}: {obj_id}") - # else: print(f"WS Info: Attempt to delete non-existent object {obj_id} by {client_id}") - else: print(f"WS Warning: Invalid delete_object payload (missing obj_id) from {client_id}: {payload}") + obj_id = payload.get("obj_id"); removed = False + if obj_id: + with world_objects_lock: + if obj_id in world_objects: del world_objects[obj_id]; removed = True + if removed: + broadcast_payload = json.dumps({"type": "object_deleted", "payload": {"obj_id": obj_id, "username": sender_username}}); + await broadcast_message(broadcast_payload, exclude_id=client_id) + else: print(f"WS Invalid delete_object payload: {payload}") elif msg_type == "player_position": - pos_data = payload.get("position"); rot_data = payload.get("rotation") # Optional rotation - # Basic validation for position data existence - if pos_data and isinstance(pos_data, dict) and 'x' in pos_data and 'y' in pos_data and 'z' in pos_data: - # Broadcast player movement to other clients - broadcast_payload = json.dumps({ - "type": "player_moved", - "payload": {"username": sender_username, "id": client_id, "position": pos_data, "rotation": rot_data} - }); - await broadcast_message(broadcast_payload, exclude_id=client_id) # Don't send back to self - # else: print(f"WS Debug: Invalid or missing player position data from {client_id}") # Can be noisy - - elif msg_type == "request_initial_state": - # Client explicitly asks for state (e.g., after reconnect) - print(f"Client {client_id} explicitly requested initial state.") - with world_objects_lock: requested_state_payload = dict(world_objects) - state_msg = json.dumps({"type": "initial_state", "payload": requested_state_payload}) - await send_safely(websocket, state_msg, client_id) - - # Add handlers for other message types if needed - - except json.JSONDecodeError: print(f"WS Error: Invalid JSON received from {client_id}: {message[:100]}...") - except Exception as e: print(f"WS Error processing message from {client_id}: {e}"); st.exception(e) # Log full traceback for debugging - - # --- Handle Client Disconnection --- - except websockets.ConnectionClosedOK: print(f"WS Client disconnected normally: {client_id} ({username})") - except websockets.ConnectionClosedError as e: print(f"WS Client connection closed with error: {client_id} ({username}) - Code: {e.code}, Reason: {e.reason}") - except Exception as e: print(f"WS Unexpected error in handler for {client_id}: {e}"); st.exception(e) + pos_data = payload.get("position"); rot_data = payload.get("rotation") + if pos_data: + broadcast_payload = json.dumps({"type": "player_moved", "payload": {"username": sender_username, "id": client_id, "position": pos_data, "rotation": rot_data}}); + await broadcast_message(broadcast_payload, exclude_id=client_id) + + except json.JSONDecodeError: print(f"WS Invalid JSON from {client_id}: {message[:100]}...") + except Exception as e: print(f"WS Error processing msg from {client_id}: {e}") + except websockets.ConnectionClosed: print(f"WS Client disconnected: {client_id} ({username})") + except Exception as e: print(f"WS Unexpected handler error {client_id}: {e}") finally: - print(f"Cleaning up connection for {client_id}...") - # Announce User Leave to others - leave_msg = json.dumps({"type": "user_leave", "payload": {"username": username, "id": client_id}}) - # Use run_async here as the handler loop is closing - run_async(broadcast_message, leave_msg, exclude_id=client_id) # Fire and forget broadcast - # Ensure client is fully unregistered - await unregister_client(websocket) # This removes from connected_clients and session_state dict - -# --- WebSocket Server Management --- -async def run_websocket_server(host="0.0.0.0", port=8765): - """Coroutine that runs the WebSocket server until stopped.""" - # Use a stop event managed in session state - if 'websocket_stop_event' not in st.session_state or st.session_state.websocket_stop_event is None: - st.session_state.websocket_stop_event = asyncio.Event() - - stop_event = st.session_state.websocket_stop_event - server = None - st.session_state.server_running_flag = True # Set flag early - print(f"Attempting to start WebSocket server on {host}:{port}...") + await broadcast_message(json.dumps({"type": "user_leave", "payload": {"username": username, "id": client_id}}), exclude_id=client_id); + await unregister_client(websocket) + +async def run_websocket_server(): + """Coroutine to run the WebSocket server.""" + if st.session_state.get('server_running_flag', False): return + st.session_state['server_running_flag'] = True; print("Attempting start WS server 0.0.0.0:8765...") + stop_event = asyncio.Event(); st.session_state['websocket_stop_event'] = stop_event + server = None try: - # Start the server - server = await websockets.serve(websocket_handler, host, port); - st.session_state['server_instance'] = server # Store server object - server_address = server.sockets[0].getsockname() # Get actual bound address - print(f"WebSocket server started successfully on {server_address}. Waiting for stop signal...") - # Keep server running until stop event is set + server = await websockets.serve(websocket_handler, "0.0.0.0", 8765); st.session_state['server_instance'] = server + print(f"WS server started: {server.sockets[0].getsockname()}. Waiting for stop signal...") await stop_event.wait() - print("Stop signal received, shutting down WebSocket server...") - - except OSError as e: - print(f"### FAILED TO START WEBSOCKET SERVER on {host}:{port}: {e} ###") - st.error(f"Server start failed: {e}. Port likely in use.") - st.session_state['server_running_flag'] = False # Reset flag on failure - except Exception as e: - print(f"### UNEXPECTED WEBSOCKET SERVER ERROR: {e} ###") - st.exception(e) # Log full traceback - st.session_state['server_running_flag'] = False # Reset flag on failure + except OSError as e: print(f"### FAILED START WS SERVER: {e}"); st.session_state['server_running_flag'] = False; + except Exception as e: print(f"### UNEXPECTED WS SERVER ERROR: {e}"); st.session_state['server_running_flag'] = False; finally: - print("WebSocket server task finishing...") - if server: - server.close() - await server.wait_closed() - print("WebSocket server closed.") - # Clear server state variables - st.session_state['server_instance'] = None - st.session_state.server_running_flag = False - # Don't clear stop event here, might be needed if restart is attempted - print("Server state cleared.") - + print("WS server task finishing..."); + if server: server.close(); await server.wait_closed(); print("WS server closed.") + st.session_state['server_running_flag'] = False; st.session_state['server_instance'] = None; st.session_state['websocket_stop_event'] = None def start_websocket_server_thread(): - """Starts the WebSocket server in a separate daemon thread.""" - # Check if already running or thread exists - if st.session_state.get('server_running_flag', False): - print("Server start requested, but flag indicates it's already running or starting.") - return - if st.session_state.get('server_task') and st.session_state.server_task.is_alive(): - print("Server start requested, but thread appears to be alive.") - return - - print("Creating and starting new WebSocket server thread.") - st.session_state.server_running_flag = True # Assume it will start - - # Define the function to run in the new thread - def run_server_in_new_loop(): - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) - try: - # Ensure stop event exists for this thread's loop - if 'websocket_stop_event' not in st.session_state or st.session_state.websocket_stop_event is None: - st.session_state.websocket_stop_event = asyncio.Event() - - # Run the server coroutine until it completes (due to stop signal or error) - loop.run_until_complete(run_websocket_server()) - except Exception as thread_e: - print(f"Error in server thread run_loop: {thread_e}") - st.session_state.server_running_flag = False # Mark as stopped on error + """Starts the WebSocket server in a separate thread if not already running.""" + if st.session_state.get('server_task') and st.session_state.server_task.is_alive(): return + if st.session_state.get('server_running_flag', False): return + print("Creating/starting new server thread."); + def run_loop(): + loop = None + try: loop = asyncio.get_running_loop() # Check if loop exists in this thread + except RuntimeError: loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop) # Create if not exists + try: loop.run_until_complete(run_websocket_server()) finally: - print("Server thread: Cleaning up event loop...") - try: - # Cancel any remaining tasks in the loop + if loop and not loop.is_closed(): tasks = asyncio.all_tasks(loop) if tasks: - for task in tasks: task.cancel() - loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True)) - loop.run_until_complete(loop.shutdown_asyncgens()) - except Exception as cleanup_e: print(f"Error during server thread loop cleanup: {cleanup_e}") - finally: - if not loop.is_closed(): loop.close(); print("Server thread event loop closed.") - # Ensure flag is false after thread finishes - st.session_state.server_running_flag = False - st.session_state.server_task = None - - - # Create and start the daemon thread - st.session_state.server_task = threading.Thread(target=run_server_in_new_loop, daemon=True); - st.session_state.server_task.start(); - time.sleep(2) # Give thread time to start and potentially fail - - # Check if thread actually started and server flag is still set - if not st.session_state.server_task.is_alive(): - print("### Server thread failed to start or exited immediately! ###") - st.session_state.server_running_flag = False # Ensure flag is correct - st.error("WebSocket server thread failed to start. Check console logs.") - elif not st.session_state.get('server_running_flag', False): - print("### Server thread started but server flag is false (likely failed during startup). ###") - st.error("WebSocket server failed to start properly. Check console logs.") - else: - print("Server thread appears to have started.") + for task in tasks: task.cancel() + try: loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True)) + except asyncio.CancelledError: pass # Expected if tasks cancelled + loop.close(); print("Server thread loop closed.") + else: print("Server thread loop already closed or None.") + st.session_state.server_task = threading.Thread(target=run_loop, daemon=True); st.session_state.server_task.start(); time.sleep(1.5) # Allow time to start + if not st.session_state.server_task.is_alive(): print("### Server thread failed to stay alive!") # ============================================================================== @@ -996,449 +673,269 @@ def render_sidebar(): st.header("💾 World Versions") st.caption("Load or save named world states.") - saved_worlds = get_saved_worlds() # Fetch list of available worlds - # Create display names mapping basename to user-friendly string - world_options_display = { - os.path.basename(w['filename']): f"{w['name']} ({w['timestamp']})" - for w in saved_worlds - } - # Basenames for radio options, add None for "Live State" + saved_worlds = get_saved_worlds() + world_options_display = {os.path.basename(w['filename']): f"{w['name']} ({w['timestamp']})" for w in saved_worlds} radio_options_basenames = [None] + [os.path.basename(w['filename']) for w in saved_worlds] - - # Get the currently selected/loaded file basename from session state current_selection_basename = st.session_state.get('current_world_file', None) - - # Find the index for the radio button based on the current selection - current_radio_index = 0 # Default to "Live State" + current_radio_index = 0 if current_selection_basename and current_selection_basename in radio_options_basenames: - try: current_radio_index = radio_options_basenames.index(current_selection_basename) - except ValueError: current_radio_index = 0 # Fallback if inconsistency + try: current_radio_index = radio_options_basenames.index(current_selection_basename) + except ValueError: current_radio_index = 0 - # --- World Selector Radio --- - st.markdown("**Load World:**") selected_basename = st.radio( - "Select a saved world to load or view live state:", # Clearer label - options=radio_options_basenames, - index=current_radio_index, - format_func=lambda x: "Live State (Unsaved Changes)" if x is None else world_options_display.get(x, x), - key="world_selector_radio", - label_visibility="collapsed" # Hide redundant label - ) - - # --- Handle World Load on Selection Change --- - if selected_basename != current_selection_basename: - st.session_state.current_world_file = selected_basename # Update session state tracking - if selected_basename: # A specific world file was selected - print(f"User selected world to load: {selected_basename}") - with st.spinner(f"Loading {world_options_display.get(selected_basename, selected_basename)}..."): - # Load data from file into server's memory (`world_objects`) - if load_world_state_from_md(selected_basename): - # IMPORTANT: Broadcast the newly loaded state to ALL clients - run_async(broadcast_world_update) # Fire-and-forget broadcast - st.toast("World loaded successfully!", icon="✅") - # No need to rerun here, broadcast handles client update. - # Let Streamlit finish the current run naturally. - else: - st.error("Failed to load world file.") - st.session_state.current_world_file = None # Revert selection on failure - else: # "Live State" was selected - print("User switched to view Live State (no file loaded).") - # No load needed, but maybe inform user? - st.toast("Switched to view Live State.") - # If switching *from* a loaded file to live state, should we clear world_objects? - # Current logic assumes world_objects always reflects the *active* state, - # whether loaded or built live. This seems reasonable. - # Trigger a rerun to update the UI elements reflecting the new state/selection - st.rerun() - - - # --- Download List --- - st.caption("Download Saved Worlds:") - # Use columns for better layout - cols_dl_header = st.columns([4, 1]) - with cols_dl_header[0]: st.write("**Name** (Timestamp)") - with cols_dl_header[1]: st.write("**DL**") - - display_limit = 10 # Show first N worlds directly - if not saved_worlds: st.caption("No saved worlds found.") + "Load World:", options=radio_options_basenames, index=current_radio_index, + format_func=lambda x: "Live State (Unsaved)" if x is None else world_options_display.get(x, x), + key="world_selector_radio" + ) + if selected_basename != current_selection_basename: + st.session_state.current_world_file = selected_basename + if selected_basename: + with st.spinner(f"Loading {selected_basename}..."): + if load_world_state_from_md(selected_basename): + run_async(broadcast_world_update); st.toast("World loaded!", icon="✅") + else: st.error("Failed to load world."); st.session_state.current_world_file = None + else: print("Switched to live state."); st.toast("Switched to Live State.") + st.rerun() + + st.caption("Download:") + cols = st.columns([4, 1]) + with cols[0]: st.write("**Name** (Timestamp)") + with cols[1]: st.write("**DL**", help="Download") + display_limit = 10 for i, world_info in enumerate(saved_worlds): f_basename = os.path.basename(world_info['filename']) - f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename) - display_name = world_info.get('name', f_basename); timestamp = world_info.get('timestamp', 'N/A') - - # Handle display limit with expander - if i >= display_limit: - with st.expander(f"Show {len(saved_worlds)-display_limit} more...", expanded=False): - for world_info_more in saved_worlds[display_limit:]: - f_basename_more = os.path.basename(world_info_more['filename']); f_fullpath_more = os.path.join(SAVED_WORLDS_DIR, f_basename_more); display_name_more = world_info_more.get('name', f_basename_more); timestamp_more = world_info_more.get('timestamp', 'N/A') - colA, colB = st.columns([4, 1]); - with colA: st.write(f"{display_name_more} ({timestamp_more})", unsafe_allow_html=True) - with colB: st.markdown(get_download_link(f_fullpath_more, "md"), unsafe_allow_html=True) - break # Stop outer loop after starting expander - - # Display items within the limit - col1, col2 = st.columns([4, 1]); - with col1: st.write(f"{display_name} ({timestamp})", unsafe_allow_html=True) - with col2: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True) + f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename) # Reconstruct full path + display_name = world_info.get('name', f_basename) + timestamp = world_info.get('timestamp', 'N/A') + if i < display_limit: + col1, col2 = st.columns([4, 1]); + with col1: st.write(f"{display_name} ({timestamp})", unsafe_allow_html=True) + with col2: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True) + elif i == display_limit: # Show expander starting from the limit item + with st.expander(f"Show {len(saved_worlds)-display_limit} more..."): + # Display the current item first inside expander + col1_exp, col2_exp = st.columns([4, 1]); + with col1_exp: st.write(f"{display_name} ({timestamp})", unsafe_allow_html=True) + with col2_exp: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True) + # Display rest inside expander + for world_info_more in saved_worlds[display_limit+1:]: + f_basename_more = os.path.basename(world_info_more['filename']); f_fullpath_more = os.path.join(SAVED_WORLDS_DIR, f_basename_more); display_name_more = world_info_more.get('name', f_basename_more); timestamp_more = world_info_more.get('timestamp', 'N/A') + colA, colB = st.columns([4, 1]); + with colA: st.write(f"{display_name_more} ({timestamp_more})", unsafe_allow_html=True) + with colB: st.markdown(get_download_link(f_fullpath_more, "md"), unsafe_allow_html=True) + break # Stop outer loop after showing expander content st.markdown("---") st.header("🏗️ Build Tools") - st.caption("Select an object type to place.") - # Use columns for a grid layout - cols_tools = st.columns(5) + st.caption("Select an object to place.") + cols = st.columns(5) col_idx = 0 - current_tool = st.session_state.get('selected_object', 'None') # Get the currently selected tool type - - # --- Tool Selection Buttons --- + current_tool = st.session_state.get('selected_object', 'None') for emoji, name in PRIMITIVE_MAP.items(): - button_key = f"primitive_tool_{name}"; - # Highlight the currently selected tool - button_type = "primary" if current_tool == name else "secondary" - # Place button in the grid - if cols_tools[col_idx % 5].button(emoji, key=button_key, help=name, type=button_type, use_container_width=True): - # --- Action on Tool Button Click --- - if st.session_state.selected_object != name: - print(f"Tool changed to: {name}") - st.session_state.selected_object = name # Update selected tool in session state - # IMPORTANT: Inform the client-side JS about the tool change - # This JS function should ONLY update the client's internal 'next object type' variable. - # It MUST NOT reset the scene. - js_command = f"if (typeof window.updateSelectedObjectType === 'function') {{ window.updateSelectedObjectType({json.dumps(name)}); }} else {{ console.warn('updateSelectedObjectType function not found on client'); }}" - run_async(lambda cmd=js_command: streamlit_js_eval(cmd, key=f"update_tool_js_{name}")) - # Rerun needed to update the button highlighting (primary/secondary) + button_key = f"primitive_{name}"; button_type = "primary" if current_tool == name else "secondary" + if cols[col_idx % 5].button(emoji, key=button_key, help=name, type=button_type, use_container_width=True): + if st.session_state.get('selected_object', 'None') != name: + st.session_state.selected_object = name + run_async(lambda name_arg=name: streamlit_js_eval(f"updateSelectedObjectType({json.dumps(name_arg)});", key=f"update_tool_js_{name_arg}")) st.rerun() - col_idx += 1 - - # --- Clear Tool Button --- - st.markdown("---") # Separator - if st.button("🚫 Clear Tool / Select Mode", key="clear_tool_button", use_container_width=True, help="Switch to selection/interaction mode (no object placement)."): - if st.session_state.selected_object != 'None': - print("Tool cleared (Select Mode enabled).") - st.session_state.selected_object = 'None'; - # Inform client JS - js_command_none = "if (typeof window.updateSelectedObjectType === 'function') { window.updateSelectedObjectType('None'); } else { console.warn('updateSelectedObjectType function not found on client'); }" - run_async(lambda: streamlit_js_eval(js_command_none, key="update_tool_js_none")) - st.rerun() # Rerun to update button highlights + st.markdown("---") + if st.button("🚫 Clear Tool", key="clear_tool", use_container_width=True): + if st.session_state.get('selected_object', 'None') != 'None': + st.session_state.selected_object = 'None'; + run_async(lambda: streamlit_js_eval("updateSelectedObjectType('None');", key="update_tool_js_none")) + st.rerun() st.markdown("---") st.header("🗣️ Voice & User") - current_username = st.session_state.get('username', list(FUN_USERNAMES.keys())[0]) # Use loaded username + current_username = st.session_state.get('username', list(FUN_USERNAMES.keys())[0]) username_options = list(FUN_USERNAMES.keys()); current_index = 0 try: current_index = username_options.index(current_username) - except ValueError: current_index = 0 # Fallback if name not in list - - # --- Username/Voice Selection --- - new_username = st.selectbox("Change Your Name/Voice:", options=username_options, index=current_index, key="username_select_widget", format_func=lambda x: x) # Show full name with emoji - + except ValueError: current_index = 0 + new_username = st.selectbox("Change Name/Voice", options=username_options, index=current_index, key="username_select", format_func=lambda x: x.split(" ")[0]) if new_username != st.session_state.username: old_username = st.session_state.username - print(f"Username changed from {old_username} to {new_username}") - st.session_state.username = new_username; - st.session_state.tts_voice = FUN_USERNAMES[new_username]; # Update voice - save_username(st.session_state.username) # Persist choice - - # Broadcast rename event (optional, good for user list UI on client) - rename_msg = json.dumps({"type":"user_rename", "payload": {"old_username": old_username, "new_username": new_username}}) - run_async(broadcast_message, rename_msg) - - # Inform the current client's JS about the username change immediately - js_user_update = f"if(window.updateUsername) {{ window.updateUsername({json.dumps(new_username)}); }} else {{ console.warn('updateUsername function not found'); }}" - run_async(lambda: streamlit_js_eval(js_user_update, key="update_user_js")) - - st.rerun() # Rerun to reflect change in UI title etc. - - # --- Audio Toggle --- - st.session_state['enable_audio'] = st.toggle("Enable TTS Audio Output", value=st.session_state.get('enable_audio', True), key="tts_toggle") + change_msg = json.dumps({"type":"user_rename", "payload": {"old_username": old_username, "new_username": new_username}}) + run_async(broadcast_message, change_msg) + st.session_state.username = new_username; st.session_state.tts_voice = FUN_USERNAMES[new_username]; save_username(st.session_state.username) + st.rerun() + st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True)) def render_main_content(): """Renders the main content area with tabs.""" - # Ensure username is initialized before using in title - username_display = st.session_state.get('username', 'N/A') - st.title(f"{Site_Name} - User: {username_display}") + st.title(f"{Site_Name} - User: {st.session_state.username}") tab_world, tab_chat, tab_pdf, tab_files = st.tabs(["🏗️ World Builder", "🗣️ Chat", "📚 PDF Tools", "📂 Files & Settings"]) # --- World Builder Tab --- with tab_world: st.header("Shared 3D World") - st.caption("Place objects using the sidebar tools. Click objects to potentially delete (implement delete logic in index.html). Changes are shared live!") - - # Display current world status + st.caption("Place objects using the sidebar tools. Changes are shared live!") current_file_basename = st.session_state.get('current_world_file', None) if current_file_basename: - try: parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file_basename)); world_name = parsed['name'] - except Exception: world_name = "Unknown" - st.info(f"Current World: **{world_name}** (Loaded from: `{current_file_basename}`)") - else: st.info("🏗️ Live State Active (Unsaved changes only persist if saved)") - - # --- Embed HTML/JS Component (index.html) --- + # Construct full path only if needed for parsing, might fail if file deleted externally + full_path_for_parse = os.path.join(SAVED_WORLDS_DIR, current_file_basename) + if os.path.exists(full_path_for_parse): + parsed = parse_world_filename(full_path_for_parse) + st.info(f"Current World: **{parsed['name']}** (`{current_file_basename}`)") + else: # File might have been deleted + st.warning(f"Loaded world file '{current_file_basename}' seems to be missing.") + st.session_state.current_world_file = None # Clear state + else: st.info("Live State Active (Unsaved changes only persist if saved)") + + # Embed HTML Component html_file_path = 'index.html' - if not os.path.exists(html_file_path): - st.error(f"CRITICAL ERROR: Could not find '{html_file_path}'. The 3D view cannot be loaded.") - return # Stop rendering this tab if HTML is missing - try: with open(html_file_path, 'r', encoding='utf-8') as f: html_template = f.read() + ws_url = "ws://localhost:8765" # Default + try: # Get WS URL (Best effort) + from streamlit.web.server.server import Server + session_info = Server.get_current()._get_session_info(st.runtime.scriptrunner.get_script_run_ctx().session_id) + # Different streamlit versions might have different attribute names + host_attr = getattr(session_info.ws.stream.request, 'host', None) # Try 'host' + if not host_attr and hasattr(session_info.client, 'request'): host_attr = getattr(session_info.client.request, 'host', None) # Try client.request + if host_attr: + server_host = host_attr.split(':')[0] + ws_url = f"ws://{server_host}:8765" + else: raise AttributeError("Host attribute not found") + except Exception as e: print(f"WS URL detection failed ({e}), using localhost.") - # --- Determine WebSocket URL --- - ws_url = "ws://localhost:8765" # Default fallback - # Attempt to dynamically get the host the browser is connected to - try: - # This relies on internal Streamlit structure, might break in future versions - # Prefer getting host from JS if possible, but this is a server-side attempt - # session_info = st.runtime.get_instance().get_client(st.runtime.scriptrunner.get_script_run_ctx().session_id) - # server_host = session_info.request.host.split(':')[0] # Needs checking if this path is valid - - # More robust: Ask JS for its `window.location.hostname` - # This requires streamlit_js_eval to be ready, might have timing issues on first load. - # Let's stick to a configurable approach or rely on JS determining it. - # For local testing, localhost is fine. For deployment, need configuration. - # Using localhost as a placeholder, assuming server runs locally relative to client. - # PRODUCTION: Replace with actual external IP/domain or configure via env var. - server_host = os.getenv("WEBSOCKET_HOST", "localhost") # Allow override via env var - ws_port = os.getenv("WEBSOCKET_PORT", "8765") - ws_proto = "ws" # Use "wss" if using TLS/SSL - ws_url = f"{ws_proto}://{server_host}:{ws_port}" - print(f"Using WebSocket URL: {ws_url}") - - except Exception as e: print(f"WS URL detection failed ({e}), using default: {ws_url}") - - # --- Inject State into JavaScript --- - # This script block will be inserted into the of index.html js_injection_script = f"""""" - # Insert the script before the closing tag html_content_with_state = html_template.replace('', js_injection_script + '\n', 1) - - # --- Render the HTML Component --- components.html(html_content_with_state, height=700, scrolling=False) - - except Exception as e: st.error(f"Error loading or embedding the 3D component: {e}"); st.exception(e) + except FileNotFoundError: st.error(f"CRITICAL ERROR: Could not find '{html_file_path}'.") + except Exception as e: st.error(f"Error loading 3D component: {e}"); st.exception(e) # --- Chat Tab --- with tab_chat: st.header(f"{START_ROOM} Chat") - # Load history async - needed if history is large, otherwise direct load is fine - # Use existing session state which gets updated by save_chat_entry - chat_history = st.session_state.get('chat_history', []) + # Load history - use run_async result or session state if already loaded + if 'chat_history' not in st.session_state or not st.session_state.chat_history: + chat_history_list = asyncio.run(load_chat_history()) # Blocking load if first time + else: chat_history_list = st.session_state.chat_history - # Display chat history (most recent messages at the bottom) chat_container = st.container(height=500) with chat_container: - if chat_history: - # Display messages, ensuring Markdown is handled - for entry in reversed(chat_history[-100:]): # Show last 100 messages - st.markdown(entry, unsafe_allow_html=True) # Allow basic HTML if needed, be cautious - else: st.caption("No chat messages yet. Say hello!") - - # --- Chat Input Form --- - # Use a form for better Enter key handling - with st.form(key="chat_form", clear_on_submit=True): - message_value = st.text_input("Your Message:", key="message_input_widget", label_visibility="collapsed", placeholder="Type your message...") - send_button_clicked = st.form_submit_button("Send Chat 💬") - - # Process message sending outside the form - if send_button_clicked and message_value.strip(): - message_to_send = message_value - # Avoid sending same message twice in quick succession - if message_to_send != st.session_state.get('last_message', ''): - st.session_state.last_message = message_to_send - voice = FUN_USERNAMES.get(st.session_state.username, EDGE_TTS_VOICES[0]) # Get current voice + if chat_history_list: st.markdown("----\n".join(reversed(chat_history_list[-50:]))) # Show last 50 + else: st.caption("No chat messages yet.") - # 1. Create WebSocket message payload - ws_message_payload = { - "type": "chat_message", - "payload": {"username": st.session_state.username, "message": message_to_send, "voice": voice} - } - ws_message_json = json.dumps(ws_message_payload) + # Chat Input Area + message_value = st.text_input("Your Message:", key="message_input", label_visibility="collapsed") + send_button_clicked = st.button("Send Chat 💬", key="send_chat_button") + should_autosend = st.session_state.get('autosend', False) and message_value - # 2. Broadcast message to other clients - run_async(broadcast_message, ws_message_json) # Fire and forget broadcast - - # 3. Save entry locally (adds to session history, saves file, generates TTS) - # This also updates st.session_state.chat_history + if send_button_clicked or should_autosend: + message_to_send = message_value + if message_to_send.strip() and message_to_send != st.session_state.get('last_message', ''): + st.session_state.last_message = message_to_send + voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural") + ws_message = json.dumps({"type": "chat_message", "payload": {"username": st.session_state.username, "message": message_to_send, "voice": voice}}) + # Use helper to run async tasks without blocking main thread excessively + run_async(broadcast_message, ws_message) run_async(save_chat_entry, st.session_state.username, message_to_send, voice) - - # No need to rerun here, session state is updated, broadcast informs others. - # Streamlit should update the chat display on the *next* natural interaction or scheduled refresh. - # If immediate update is desired, could potentially use js_eval to add message client-side, - # but relying on session state update is usually sufficient. - # Force immediate redraw of chat (might feel sluggish): st.rerun() - + st.session_state.message_input = "" # Clear state for next run + st.rerun() elif send_button_clicked: st.toast("Message empty or same as last.") - # Autosend option removed for simplicity, form submit is clearer + st.checkbox("Autosend Chat", key="autosend") # --- PDF Tab --- with tab_pdf: - st.header("📚 PDF Tools") - st.caption("Extract text from PDF pages and generate audio using Edge TTS.") - pdf_file = st.file_uploader("Upload PDF for Audio Conversion", type="pdf", key="pdf_upload_widget") - max_pages = st.slider('Max Pages to Process:', 1, 50, 10, key="pdf_pages_slider", help="Limits processing to the first N pages.") - - if pdf_file: - if st.button("Process PDF to Audio 🔊", key="process_pdf_button"): - # Show spinner during processing - with st.spinner(f"Processing '{pdf_file.name}'... This may take time."): - process_pdf_tab(pdf_file, max_pages, st.session_state.tts_voice) - st.caption("Click the button above to start processing the uploaded PDF.") - else: st.info("Upload a PDF file using the uploader above.") - + st.header("📚 PDF Tools") + pdf_file = st.file_uploader("Upload PDF for Audio Conversion", type="pdf", key="pdf_upload") + max_pages = st.slider('Max Pages to Process', 1, 50, 10, key="pdf_pages") + if pdf_file: + # Use a button to trigger potentially long processing + if st.button("Process PDF to Audio", key="process_pdf_button"): + with st.spinner("Processing PDF... This may take time."): + process_pdf_tab(pdf_file, max_pages, st.session_state.tts_voice) # --- Files & Settings Tab --- with tab_files: - st.header("📂 Files, Settings & Server") + st.header("📂 Files & Settings") st.subheader("💾 World State Management") current_file_basename = st.session_state.get('current_world_file', None) - # --- Overwrite Save --- - save_col, save_as_col = st.columns(2) - with save_col: - # Enable overwrite only if a world is currently loaded - can_overwrite = current_file_basename is not None - if st.button("💾 Save Changes", key="save_current_world_button", disabled=not can_overwrite, help="Overwrite the currently loaded world file with the live state."): - if current_file_basename: # Should always be true if button is enabled - parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file_basename)) - world_name_to_save = parsed.get('name', current_file_basename) - with st.spinner(f"Overwriting '{world_name_to_save}'..."): - if save_world_state_to_md(current_file_basename): st.success(f"World '{world_name_to_save}' saved successfully!") - else: st.error("Failed to save world state.") - else: st.warning("No world file loaded to save over.") # Should not happen if disabled logic works - elif not can_overwrite: st.caption("Load a world from the sidebar to enable saving changes to it.") - - # --- Save As New --- - with save_as_col: - st.text_input("New World Name:", key="new_world_name_input", value=st.session_state.get('new_world_name', 'MyWorld')) - if st.button("💾 Save Live State as New", key="save_new_version_button", help="Save the current live state as a new world file."): - new_name = st.session_state.new_world_name_input.strip() - if new_name: - new_filename_base = generate_world_save_filename(new_name) - with st.spinner(f"Saving new version '{new_name}'..."): - if save_world_state_to_md(new_filename_base): - st.success(f"Saved as new world: '{new_filename_base}'") - # Update state to reflect the newly saved file is now "loaded" - st.session_state.current_world_file = new_filename_base; - st.session_state.new_world_name = "MyWorld"; # Reset input for next time - st.rerun() # Rerun to update sidebar selection and file list - else: st.error("Failed to save new version.") - else: st.warning("Please enter a name for the new world version.") + # Save Current Version Button + if current_file_basename: + # Need full path to parse filename correctly + full_path_for_parse = os.path.join(SAVED_WORLDS_DIR, current_file_basename) + # Check existence before parsing display name + if os.path.exists(full_path_for_parse): + parsed = parse_world_filename(full_path_for_parse) + save_label = f"Save Changes to '{parsed['name']}'" + if st.button(save_label, key="save_current_world", help=f"Overwrite '{current_file_basename}'"): + with st.spinner(f"Overwriting {current_file_basename}..."): + if save_world_state_to_md(current_file_basename): st.success("Current world saved!") + else: st.error("Failed to save world state.") + else: + st.warning(f"Currently selected world file '{current_file_basename}' not found. Cannot save changes to it.") + else: + st.info("Load a world from the sidebar to enable saving changes to it.") + + # Save As New Version Section + st.subheader("Save As New Version") + # Ensure key for text input is unique if it exists elsewhere + new_name_files = st.text_input("New World Name:", key="new_world_name_files_tab", value=st.session_state.get('new_world_name', 'MyWorld')) + if st.button("💾 Save Live State as New Version", key="save_new_version_files"): + if new_name_files.strip(): + new_filename_base = generate_world_save_filename(new_name_files) + with st.spinner(f"Saving new version '{new_name_files}'..."): + if save_world_state_to_md(new_filename_base): + st.success(f"Saved as {new_filename_base}") + st.session_state.current_world_file = new_filename_base + st.session_state.new_world_name = "MyWorld"; st.rerun() # Rerun to update sidebar + else: st.error("Failed to save new version.") + else: st.warning("Please enter a name.") - st.markdown("---") st.subheader("⚙️ Server Status") - # Check server thread status more reliably - server_thread = st.session_state.get('server_task') - server_thread_alive = server_thread is not None and server_thread.is_alive() - # Use the running flag as primary indicator, as thread might be alive but server failed startup - server_running = st.session_state.get('server_running_flag', False) and server_thread_alive - col_ws, col_clients = st.columns(2) with col_ws: - ws_status = "Running" if server_running else "Stopped" - st.metric("WebSocket Server", ws_status) - # Show start/stop button based on status - if not server_running: - if st.button("Start Server", key="start_ws_button"): start_websocket_server_thread(); time.sleep(1); st.rerun() # Allow time for thread start attempt - else: - if st.button("Stop Server", key="stop_ws_button", type="primary"): - if st.session_state.get('websocket_stop_event'): - print("Setting stop event for WebSocket server...") - st.session_state.websocket_stop_event.set() # Signal server loop to stop - st.session_state.websocket_stop_event = None # Clear event for potential restart - time.sleep(1) # Give server time to react - st.rerun() - else: st.warning("Stop event not found, cannot stop server gracefully.") - - with col_clients: - # Get client count safely from the global set - st.metric("Connected Clients", len(connected_clients)) + server_alive = st.session_state.get('server_task') and st.session_state.server_task.is_alive(); ws_status = "Running" if server_alive else "Stopped"; st.metric("WebSocket Server", ws_status) + if not server_alive and st.button("Restart Server Thread", key="restart_ws"): start_websocket_server_thread(); st.rerun() + with col_clients: st.metric("Connected Clients", len(connected_clients)) - - st.markdown("---") - st.subheader("🗑️ Delete Generated Files") + # File Deletion + st.subheader("🗑️ Delete Files") st.warning("Deletion is permanent!", icon="⚠️") - # Use columns for delete buttons col_del1, col_del2, col_del3, col_del4 = st.columns(4) with col_del1: - if st.button("🗑️ Chats", key="del_chat_button"): delete_files([os.path.join(CHAT_DIR, "*.md")]); st.session_state.chat_history = []; st.rerun() + if st.button("🗑️ Chats", key="del_chat_md"): delete_files([os.path.join(CHAT_DIR, "*.md")]); st.session_state.chat_history = []; st.rerun() with col_del2: - if st.button("🗑️ Audio", key="del_audio_button"): delete_files([os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "metadata.json")]); st.session_state.audio_cache = {}; st.rerun() + if st.button("🗑️ Audio", key="del_audio_mp3"): delete_files([os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3")]); st.session_state.audio_cache = {}; st.rerun() with col_del3: - # Be specific with world file pattern - if st.button("🗑️ Worlds", key="del_worlds_button"): delete_files([os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")]); st.session_state.current_world_file = None; run_async(broadcast_world_update); st.rerun() # Clear current selection and notify clients + # Use prefix in delete pattern + if st.button("🗑️ Worlds", key="del_worlds_md"): delete_files([os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")]); st.session_state.current_world_file = None; st.rerun() with col_del4: - if st.button("🗑️ All Gen", key="del_all_gen_button", type="primary"): - patterns = [ - os.path.join(CHAT_DIR, "*.md"), - os.path.join(AUDIO_DIR, "*.mp3"), - os.path.join(AUDIO_CACHE_DIR, "*.mp3"), - os.path.join(AUDIO_CACHE_DIR, "metadata.json"), - os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md"), - os.path.join(MEDIA_DIR, "*.zip"), # Zip files in base dir - os.path.join(MEDIA_DIR, "*_pasted_*.png") # Pasted images in base dir - ] - delete_files(patterns) - # Reset relevant session state parts - st.session_state.chat_history = []; st.session_state.audio_cache = {}; st.session_state.current_world_file = None; - # Clear server world state and notify clients - with world_objects_lock: world_objects.clear() - run_async(broadcast_world_update) - st.rerun() + if st.button("🗑️ All Gen", key="del_all_gen"): delete_files([os.path.join(CHAT_DIR, "*.md"), os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3"), os.path.join(SAVED_WORLDS_DIR, "*.md"), os.path.join(MEDIA_DIR, "*.zip")]); st.session_state.chat_history = []; st.session_state.audio_cache = {}; st.session_state.current_world_file = None; st.rerun() - st.markdown("---") + # Download Archives st.subheader("📦 Download Archives") - # Buttons to create Zip archives - col_zip1, col_zip2, col_zip3 = st.columns(3) - with col_zip1: - if st.button("Zip Worlds 📦"): - world_files_full_paths = [os.path.join(SAVED_WORLDS_DIR, os.path.basename(w['filename'])) for w in get_saved_worlds()] - create_zip_of_files(world_files_full_paths, "Worlds"); st.rerun() - with col_zip2: - if st.button("Zip Chats 📦"): create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats"); st.rerun() - with col_zip3: - if st.button("Zip Audio 📦"): create_zip_of_files(glob.glob(os.path.join(AUDIO_DIR, "*.mp3")) + glob.glob(os.path.join(AUDIO_CACHE_DIR, "*.mp3")), "Audio"); st.rerun() - - # List existing Zip files for download zip_files = sorted(glob.glob(os.path.join(MEDIA_DIR,"*.zip")), key=os.path.getmtime, reverse=True) if zip_files: - st.caption("Existing Zip Archives:") - for zip_file in zip_files: - # Display filename and download link - col_zip_name, col_zip_dl = st.columns([4,1]) - with col_zip_name: st.write(f"{os.path.basename(zip_file)}", unsafe_allow_html=True) - with col_zip_dl: st.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True) - else: st.caption("No zip archives created yet.") - + col_zip1, col_zip2, col_zip3 = st.columns(3) + # Gather files for zipping inside the button click + with col_zip1: + if st.button("Zip Worlds"): create_zip_of_files(glob.glob(os.path.join(SAVED_WORLDS_DIR, "*.md")), "Worlds") + with col_zip2: + if st.button("Zip Chats"): create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats") + with col_zip3: + if st.button("Zip Audio"): create_zip_of_files(glob.glob(os.path.join(AUDIO_DIR, "*.mp3")) + glob.glob(os.path.join(AUDIO_CACHE_DIR, "*.mp3")), "Audio") + + st.caption("Existing Zip Files:") + for zip_file in zip_files: st.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True) + else: + # Correct indentation for the else block + st.caption("No zip archives found.") # ============================================================================== # Main Execution Logic @@ -1446,30 +943,19 @@ def render_main_content(): def initialize_world(): """Loads initial world state (most recent) if not already done for this session.""" - # Only run this once per Streamlit session if not st.session_state.get('initial_world_state_loaded', False): - print("Performing initial world load check for session...") - saved_worlds = get_saved_worlds() # Get sorted list - loaded_file_basename = None - + print("Performing initial world load for session...") + saved_worlds = get_saved_worlds() + loaded_successfully = False if saved_worlds: - # Load the most recent valid world file found - latest_world_file_basename = os.path.basename(saved_worlds[0]['filename']) - print(f"Attempting to load most recent world on startup: {latest_world_file_basename}") - # load_world_state_from_md updates world_objects and sets current_world_file on success - if load_world_state_from_md(latest_world_file_basename): - print(f"Successfully loaded initial world: {latest_world_file_basename}") - loaded_file_basename = latest_world_file_basename # Keep track - else: - print("Failed to load most recent world, starting empty.") - with world_objects_lock: world_objects.clear() # Ensure clean state on failure - st.session_state.current_world_file = None # Ensure no file is marked as loaded - else: - print("No saved worlds found, starting with empty state.") - with world_objects_lock: world_objects.clear() # Ensure clean state - st.session_state.current_world_file = None - - # Mark initial load as complete, regardless of success + latest_world_file_basename = os.path.basename(saved_worlds[0]['filename']) + print(f"Loading most recent world on startup: {latest_world_file_basename}") + if load_world_state_from_md(latest_world_file_basename): loaded_successfully = True + else: print("Failed to load most recent world, starting empty.") + else: print("No saved worlds found, starting with empty state.") + if not loaded_successfully: + with world_objects_lock: world_objects.clear(); # Ensure empty state + st.session_state.current_world_file = None st.session_state.initial_world_state_loaded = True print("Initial world load process complete.") @@ -1477,25 +963,14 @@ if __name__ == "__main__": # 1. Initialize session state (must be first) init_session_state() - # 2. Start WebSocket server thread if not running - # Check both flag and thread aliveness for robustness - server_thread = st.session_state.get('server_task') - server_thread_alive = server_thread is not None and server_thread.is_alive() - if not st.session_state.get('server_running_flag', False) or not server_thread_alive: - print("Main: Server detected as not running or thread dead, attempting start...") - start_websocket_server_thread() - else: - print("Main: Server appears to be running.") - - # 3. Load initial world state (once per session, after server thread start attempt) + # 2. Start WebSocket server thread if needed + server_thread = st.session_state.get('server_task'); server_alive = server_thread is not None and server_thread.is_alive() + if not st.session_state.get('server_running_flag', False) and not server_alive: start_websocket_server_thread() + elif server_alive and not st.session_state.get('server_running_flag', False): st.session_state.server_running_flag = True # Correct flag + + # 3. Load initial world state (once per session) initialize_world() - # 4. Render UI components + # 4. Render the UI render_sidebar() - render_main_content() - - # 5. Optional: Auto-refresh mechanism (if needed, be cautious of performance) - if st.session_state.get('auto_refresh', False): - refresh_interval = st.session_state.get('refresh_rate', 30) - time.sleep(refresh_interval) - st.rerun() \ No newline at end of file + render_main_content() \ No newline at end of file