Update wrdler/gradio_ui.py

wrdler/gradio_ui.py

@@ -300,7 +300,14 @@ def get_wordlist_files() -> List[str]:
 
 @lru_cache(maxsize=32)
 def load_word_list_gradio(selected_file: Optional[str] = None) -> Dict[int, List[str]]:
-    """Load word list without Streamlit dependencies."""
+    """Load word list without Streamlit dependencies.
+    
+    Returns:
+        Dict mapping word length to list of words
+        
+    Note: For AI generation scenarios, raises FileNotFoundError if file doesn't exist.
+    For regular wordlist loading, returns FALLBACK_WORDS on any error.
+    """
     import re
 
     words_by_len: Dict[int, List[str]] = {4: [], 5: [], 6: []}
@@ -313,6 +320,14 @@ def load_word_list_gradio(selected_file: Optional[str] = None) -> Dict[int, List
         else:
             path = os.path.join(words_dir, "wordlist.txt")
 
+        # Check if file exists - raise FileNotFoundError for AI topics
+        if not os.path.isfile(path):
+            # If this looks like an AI-generated topic file (not a standard wordlist), raise exception
+            if selected_file and not selected_file.startswith(("wordlist", "classic", "scrabble")):
+                raise FileNotFoundError(f"Word list file not found: {selected_file}")
+            # For standard wordlists, fall through to fallback
+            raise FileNotFoundError(f"Standard wordlist not found: {path}")
+
         with open(path, "r", encoding="utf-8") as f:
             text = f.read()
 
@@ -333,17 +348,28 @@ def load_word_list_gradio(selected_file: Optional[str] = None) -> Dict[int, List
 
         # Check minimum requirements
         counts = {k: len(v) for k, v in words_by_len.items()}
+        
+        # If file has sufficient words, return them
         if all(counts[k] >= MIN_REQUIRED for k in (4, 5, 6)):
             return words_by_len
 
-        # Fallback for insufficient words
+        # File exists but has insufficient words
+        # For AI topic files, raise exception to trigger generation
+        if selected_file and not selected_file.startswith(("wordlist", "classic", "scrabble")):
+            raise ValueError(f"File {selected_file} has insufficient words: {counts}")
+        
+        # For standard wordlists with insufficient words, return what we have mixed with fallback
         return {
             4: words_by_len[4] if counts[4] >= MIN_REQUIRED else FALLBACK_WORDS[4],
             5: words_by_len[5] if counts[5] >= MIN_REQUIRED else FALLBACK_WORDS[5],
             6: words_by_len[6] if counts[6] >= MIN_REQUIRED else FALLBACK_WORDS[6],
         }
 
+    except (FileNotFoundError, ValueError):
+        # Re-raise for AI generation scenarios
+        raise
     except Exception:
+        # For other errors (e.g., permission issues), fall back to defaults
         return FALLBACK_WORDS.copy()
 
 
@@ -358,13 +384,17 @@ def create_new_game_state(
     ai_topic: str = ""
 ) -> Dict[str, Any]:
     """Create a new game state dictionary for gr.State."""
+    # print(f"[DEBUG] create_new_game_state called with wordlist={wordlist}, ai_topic='{ai_topic}'")
+    
     # Handle AI Generated word list
     if wordlist == "AI Generated" and ai_topic.strip():
+        # print(f"[DEBUG] AI Generation condition met! Topic: '{ai_topic.strip()}'")
         import re as re_module
         # Convert topic to filename (same logic as _save_ai_words_to_file)
         safe_topic = re_module.sub(r'[^\w\s-]', '', ai_topic.strip().lower()).strip()
         safe_topic = re_module.sub(r'[-\s]+', '_', safe_topic)
         topic_filename = f"{safe_topic}.txt"
+        # print(f"[DEBUG] Topic filename: {topic_filename}")
 
         # First try to load existing words from the topic file
         words_by_len = None
@@ -374,14 +404,25 @@ def create_new_game_state(
             has_enough = all(len(existing_words.get(length, [])) >= MIN_REQUIRED for length in (4, 5, 6))
             if has_enough:
                 words_by_len = existing_words
-        except Exception:
-            pass
+                # print(f"[DEBUG] ✅ Loaded {sum(len(v) for v in existing_words.values())} existing words from {topic_filename}")
+            else:
+                pass
+                # print(f"[DEBUG] ⚠️ File {topic_filename} exists but has insufficient words. Will generate AI words.")
+        except (FileNotFoundError, ValueError) as ex:
+            print(f"[DEBUG] File {topic_filename} not found or insufficient. Will generate AI words.")
+        except Exception as ex:
+            print(f"[DEBUG] Error loading {topic_filename}: {ex}. Will generate AI words.")
 
         # If no existing file or not enough words, generate new AI words
         if words_by_len is None:
             try:
+                # print(f"[DEBUG] 🎮 Starting AI word generation for topic '{ai_topic.strip()}'...")
+                
                 # Generate AI words - returns list of 75 words
                 ai_words, _, _ = generate_ai_words(topic=ai_topic.strip())
+                
+                # print(f"[DEBUG] ✅ AI generation complete! Got {len(ai_words)} words")
+                
                 # Convert to words_by_len format
                 words_by_len = {4: [], 5: [], 6: []}
                 for word in ai_words:
@@ -392,13 +433,19 @@ def create_new_game_state(
                 for length in (4, 5, 6):
                     if len(words_by_len[length]) < MIN_REQUIRED:
                         # Fall back to default words
+                        # print(f"[DEBUG] ⚠️ Not enough {length}-letter words, using fallback")
                         words_by_len[length] = FALLBACK_WORDS[length].copy()
             except Exception as e:
                 # Fall back to default word list on error
+                # print(f"[DEBUG] ❌ AI generation exception: {e}")
+                import traceback
+                traceback.print_exc()
                 words_by_len = load_word_list_gradio("classic.txt")
     else:
+        # print(f"[DEBUG] Using regular wordlist: {wordlist}")
         words_by_len = load_word_list_gradio(wordlist if wordlist != "AI Generated" else "classic.txt")
 
+    # print(f"[DEBUG] Creating puzzle with {sum(len(v) for v in words_by_len.values())} total words")
     puzzle = generate_puzzle(
         grid_rows=GRID_ROWS,
         grid_cols=GRID_COLS,
@@ -532,7 +579,7 @@ def get_cell_label(state: Dict[str, Any], row: int, col: int) -> str:
         letter = letter_map.get(coord_str, "")
         return letter if letter else "\u00A0"  # Non-breaking space for empty revealed cells
     else:
-        return "?"
+        return " "  # Empty space for unrevealed cells instead of "?"
 
 
 def get_cell_variant(state: Dict[str, Any], row: int, col: int) -> str:
@@ -681,7 +728,7 @@ def render_score_panel_html(state: Dict[str, Any]) -> str:
                 f'</tr>'
             )
         else:
-            hidden = "?" * len(text)
+            hidden = "_" * len(text)
             base_points = len(text)
             table_rows.append(
                 f'<tr class="hidden">'
@@ -1352,7 +1399,7 @@ def create_app() -> gr.Blocks:
                                 with gr.Row(elem_classes=["wrdler-grid-row"]):
                                     for col in range(GRID_COLS):
                                         btn = gr.Button(
-                                            value="?",
+                                            value=" ",
                                             variant="primary",
                                             size="sm",
                                             min_width=20,