Create main.py

main.py

@@ -0,0 +1,233 @@
+import gradio as gr
+import re
+from collections import defaultdict
+
+# --- Core Wordle Solver Logic (from the console app) ---
+
+def load_words():
+    """Load 5-letter words from the words.txt file."""
+    words = []
+    try:
+        with open('words.txt', 'r') as f:
+            for line in f:
+                word = line.strip().lower()
+                if len(word) == 5 and word.isalpha():
+                    words.append(word)
+    except FileNotFoundError:
+        print("FATAL ERROR: words.txt not found. Please create it in the same directory.")
+        return None
+    return words
+
+WORD_LIST = load_words()
+
+def word_matches_clue(word, guess_word, emoji_result):
+    """Check if a word is consistent with a single guess clue."""
+    # Green check: letters must match at the exact position
+    for i, (guess_char, emoji) in enumerate(zip(guess_word, emoji_result)):
+        if emoji == '🟩' and word[i] != guess_char:
+            return False
+
+    # Yellow check: letter must be in the word but not at this position
+    for i, (guess_char, emoji) in enumerate(zip(guess_word, emoji_result)):
+        if emoji == '🟨':
+            if guess_char not in word or word[i] == guess_char:
+                return False
+
+    # Red/Black check: letter should not be in the word, unless it was also a green/yellow
+    # This handles duplicate letters correctly.
+    for i, (guess_char, emoji) in enumerate(zip(guess_word, emoji_result)):
+         if emoji in ['🟥', '⬛']:
+            # Count occurrences of the letter in the guess and the word
+            guess_char_count_in_clues = sum(1 for j, g_char in enumerate(guess_word) if g_char == guess_char and emoji_result[j] in ['🟩', '🟨'])
+            word_char_count = word.count(guess_char)
+            if word_char_count > guess_char_count_in_clues:
+                return False
+
+    return True
+
+def filter_words_by_clues(words, clues):
+    """Filter the main word list based on all collected clues."""
+    if not clues:
+        return words
+    
+    remaining_words = list(words)
+    for guess_word, emoji_result in clues:
+        remaining_words = [word for word in remaining_words if word_matches_clue(word, guess_word, emoji_result)]
+        
+    return remaining_words
+
+def get_letter_frequency(words):
+    """Calculate the frequency of each letter in the remaining possible words."""
+    freq = defaultdict(int)
+    for word in words:
+        for char in set(word): # Count each letter only once per word
+            freq[char] += 1
+    return freq
+
+def score_word(word, letter_freq):
+    """Score a word based on the frequency of its unique letters."""
+    score = 0
+    used_letters = set()
+    for char in word:
+        if char not in used_letters:
+            score += letter_freq[char]
+            used_letters.add(char)
+    return score
+
+def get_best_guess(words, all_words):
+    """Determine the best next guess to narrow down possibilities."""
+    if not words:
+        return None, "No words match the clues."
+
+    if len(words) <= 2:
+        return words[0], f"{len(words)} possible words remain."
+
+    letter_freq = get_letter_frequency(words)
+    
+    # We check from the entire word list to find a word that might reveal more information
+    # even if it's not in the list of possibilities. 'salet' is a great opener for this reason.
+    best_word = max(all_words, key=lambda w: score_word(w, letter_freq))
+    
+    return best_word, f"{len(words)} possible words remain."
+
+
+# --- Gradio Interface Functions ---
+
+def process_guess(word, emojis, current_clues_list):
+    """
+    Handles the 'Submit Guess' button click.
+    Validates input, updates state, filters words, and returns new UI values.
+    """
+    # 1. Validation
+    if not word or not emojis:
+        error = "Please enter both a word and the emoji results."
+        return current_clues_list, gr.update(visible=True, value=error), "", "", format_clues_history(current_clues_list)
+
+    word = word.strip().lower()
+    emojis = emojis.strip()
+
+    if len(word) != 5 or not word.isalpha():
+        error = "Please enter a valid 5-letter word."
+        return current_clues_list, gr.update(visible=True, value=error), "", "", format_clues_history(current_clues_list)
+        
+    if len(emojis) != 5 or not all(e in "🟩🟨🟥⬛" for e in emojis):
+        error = "Emojis must be 5 characters long and contain only 🟩, 🟨, 🟥, or ⬛."
+        return current_clues_list, gr.update(visible=True, value=error), "", "", format_clues_history(current_clues_list)
+
+    # 2. Update State
+    new_clue = (word, emojis)
+    if new_clue not in current_clues_list:
+        current_clues_list.append(new_clue)
+    
+    # 3. Core Logic
+    remaining_words = filter_words_by_clues(WORD_LIST, current_clues_list)
+    best_guess, status_text = get_best_guess(remaining_words, WORD_LIST)
+
+    # 4. Format Output
+    history_md = format_clues_history(current_clues_list)
+    
+    if not remaining_words:
+        best_guess_str = "😕"
+        status_text = "No words match your clues. There might be an error in your input. Please reset and try again."
+    elif len(remaining_words) == 1:
+         best_guess_str = remaining_words[0].upper()
+         status_text = "🎉 Found it! This is the only possible word."
+    else:
+        best_guess_str = best_guess.upper()
+
+    return current_clues_list, gr.update(visible=False, value=""), best_guess_str, status_text, history_md
+
+def get_other_suggestions(current_clues_list):
+    """Handles the 'Get Other Suggestions' button click."""
+    if not current_clues_list:
+        return "Enter at least one guess to get suggestions."
+        
+    remaining_words = filter_words_by_clues(WORD_LIST, current_clues_list)
+    
+    if not remaining_words:
+        return "No words match the current clues."
+    
+    if len(remaining_words) == 1:
+        return f"Only one word remains: **{remaining_words[0].upper()}**"
+
+    letter_freq = get_letter_frequency(remaining_words)
+    scored_words = sorted([(word, score_word(word, letter_freq)) for word in remaining_words], key=lambda x: x[1], reverse=True)
+    
+    # Format suggestions into a markdown list
+    suggestions_md = f"### Top Suggestions ({len(remaining_words)} words remain)\n"
+    for word, score in scored_words[:10]:
+        suggestions_md += f"- **{word.upper()}**\n"
+        
+    if len(scored_words) > 10:
+        suggestions_md += f"\n...and {len(scored_words) - 10} more."
+        
+    return suggestions_md
+
+def reset_session():
+    """Clears all inputs, outputs, and the session state."""
+    return [], "", "", "", "No guesses yet. Enter your first guess above.", "", gr.update(visible=False, value="")
+
+def format_clues_history(clues_list):
+    """Converts the list of clues into a markdown string for display."""
+    if not clues_list:
+        return "No guesses yet. Enter your first guess above."
+    
+    md = "### Your Guess History\n"
+    for word, emojis in clues_list:
+        md += f"- `{word.upper()}` -> {emojis}\n"
+    return md
+
+# --- Gradio UI Layout ---
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Wordle Solver Bot") as demo:
+    # State object to store the list of clues for the session
+    session_clues = gr.State([])
+
+    gr.Markdown("# 🧩 Wordle Solver Bot")
+    gr.Markdown("Enter your Wordle guesses below, and I'll suggest the best next word to try!")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            word_input = gr.Textbox(label="Guessed Word", placeholder="e.g., CRANE")
+            emoji_input = gr.Textbox(label="Emoji Results", placeholder="e.g., 🟥🟨🟩🟥🟥")
+            error_box = gr.Textbox(label="Error", visible=False, interactive=False)
+            with gr.Row():
+                submit_button = gr.Button("Submit Guess", variant="primary")
+                other_button = gr.Button("Get Other Suggestions")
+                reset_button = gr.Button("Reset Session", variant="stop")
+
+        with gr.Column(scale=3):
+            best_guess_output = gr.Textbox(label="💡 Best Next Guess", interactive=False)
+            status_output = gr.Textbox(label="📊 Status", interactive=False)
+            
+    with gr.Row():
+        with gr.Column():
+            history_output = gr.Markdown("No guesses yet. Enter your first guess above.")
+        with gr.Column():
+            other_suggestions_output = gr.Markdown("")
+
+    # --- Event Handlers ---
+    submit_button.click(
+        fn=process_guess,
+        inputs=[word_input, emoji_input, session_clues],
+        outputs=[session_clues, error_box, best_guess_output, status_output, history_output]
+    )
+
+    other_button.click(
+        fn=get_other_suggestions,
+        inputs=[session_clues],
+        outputs=[other_suggestions_output]
+    )
+
+    reset_button.click(
+        fn=reset_session,
+        inputs=[],
+        outputs=[session_clues, word_input, emoji_input, best_guess_output, history_output, status_output, error_box]
+    )
+
+if __name__ == "__main__":
+    if not WORD_LIST:
+        print("Could not start the application because 'words.txt' is missing or empty.")
+    else:
+        print("Starting Gradio app... Access it at the URL provided below.")
+        demo.launch()