Initial Commit

app.py

@@ -0,0 +1,17 @@
+import streamlit as st
+import pandas as pd
+from src.game import Wordle
+
+
+st.title("WORDLE")
+
+
+with st.form("Wordle"):
+    button = st.form_submit_button("Play")
+    box = st.selectbox("Select the trial level :",["6","100"])
+    if button:
+        wordle = Wordle(int(box))
+        chosen_word,game_diction = wordle.play()
+        st.dataframe(pd.DataFrame.from_dict(game_diction))
+        st.write(f"The actual word is : {wordle.wordle}")
+        st.write(f"It took {len(game_diction['step_no'])} random search steps to find it")

requirements.txt

@@ -0,0 +1,3 @@
+nltk==3.6.2
+pandas==1.3.0
+streamlit==0.84.0

src/agent.py

@@ -0,0 +1,34 @@
+import random
+from src.metrics import get_word_list
+
+
+class Cerebrum:
+    def __init__(self,vowel_knowledge:int=2) -> None:
+        self.word_list = get_word_list()
+        self.init_word_list = self.get_vowelled_word_list(vowel_knowledge)
+    
+    def get_vowelled_word_list(self,nos_vowels:int)->list:
+        """
+        Returns a list of words with the given number of vowels.
+        """
+        vowels = set(["a","e","i","o","u"])
+        tmp_list = []
+        for word in self.word_list:
+            ind_word_set = set(list(word))
+            if len(list(vowels.intersection(ind_word_set))) > nos_vowels:
+                tmp_list.append(word)
+        return tmp_list
+
+    def random_first_choice(self)->str:
+        return random.choice(self.init_word_list)
+
+    def random_n_choice(self,hash_output:list[list])->str:
+        if len(hash_output) == 1:
+            return random.choice(hash_output[0])
+        else:
+            sub_hash = random.choice(hash_output)
+            return random.choice(sub_hash)
+
+if __name__ == "__main__":
+    cerebrum = Cerebrum()
+    print(len(cerebrum.init_word_list))

src/game.py

@@ -0,0 +1,99 @@
+from itertools import count
+from src.metrics import get_word_list,Metrics
+import logging
+import random
+from src.utils import WordHash
+from src.agent import Cerebrum
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+
+
+
+class Wordle:
+    def __init__(self,steps_to_be_tried=6) -> None:
+        self.steps = steps_to_be_tried
+        self.word_list = get_word_list()
+        self.letter_list = list("abcdefghijklmnopqrstuvwxyz")
+        self.wordle = random.choice(self.word_list)
+        self.sixth_sense = Cerebrum()
+        self.hash = WordHash()
+        logger.info(f"The Word to be found is {self.wordle}")
+        self.evaluator = Metrics()
+
+    def deduct_vocab(self,score_dict:dict):
+        """
+        Returns True if the word is present in the vocab.
+        """
+        for letter in score_dict:
+            if score_dict[letter] == 0:
+                if letter in self.letter_list:
+                    del self.letter_list[self.letter_list.index(letter)]
+
+    def preprocess_pos_word(self,pos_score_dict:dict):
+        """
+        Flag : G -> Sure, Y -> Probable
+        """
+        pos_slice_list_g = []
+        pos_slice_list_y = []
+        for ind in range(len(pos_score_dict)):
+            letter = list(pos_score_dict.keys())[ind]
+            score = pos_score_dict[letter]
+            if score == 2:
+                pos_slice_list_g.append([ind,letter,"G"])
+            if score == 1:
+                for possible_index in range(5):
+                    if possible_index != ind:
+                        pos_slice_list_y.append([possible_index,letter,"Y"])
+
+        return pos_slice_list_g + pos_slice_list_y
+
+    def single_step(self,pred_word:str):
+        pos_score_dict = self.evaluator(self.wordle,pred_word)
+        self.deduct_vocab(pos_score_dict)
+
+        return pos_score_dict
+
+    def play(self)->str:
+        game_diction = {"step_no":[],"chosen_word":[],"status":[]}
+        for step in range(self.steps):
+            logger.info(f"Step {step}")
+            if step == 0:
+                chosen =  self.sixth_sense.random_first_choice()
+                logger.info(f"Chosen word is {chosen}")
+                pos_score_dict = self.single_step(chosen)
+                slice_pos_list = self.hash.slice_pos(self.preprocess_pos_word(pos_score_dict))
+                game_diction["chosen_word"].append(chosen)
+                game_diction["step_no"].append(step)
+                game_diction["status"].append("CONTINUE")
+            else:
+
+                chosen = self.sixth_sense.random_n_choice(slice_pos_list)
+                logger.info(f"Chosen word is {chosen}")
+                pos_score_dict = self.single_step(chosen)
+                slice_pos_list = self.hash.slice_pos(self.preprocess_pos_word(pos_score_dict))
+                game_diction["chosen_word"].append(chosen)
+                game_diction["step_no"].append(step)
+                if chosen != self.wordle:
+                    game_diction["status"].append("CONTINUE")
+                elif chosen == self.wordle:
+                    game_diction["status"].append("IMPRESSIVE")
+                    logger.info(f"The word is {chosen}")
+                    break
+        return chosen,game_diction
+
+
+
+
+
+if __name__ == "__main__":
+    pass
+    # pos_score_dict = wordle_module.single_step("cants")
+    # print(pos_score_dict)
+    # slice_pos_list = wordle_module.preprocess_pos_word(pos_score_dict)
+    # print(slice_pos_list)
+    # hash = WordHash()
+    # print(hash.slice_pos(slice_pos_list))

src/metrics.py

@@ -0,0 +1,45 @@
+from nltk import corpus
+
+
+def get_word_list()->list:
+
+    return [ i for i in corpus.words.words() if len(i) == 5]
+
+
+
+class Metrics:
+    def __init__(self):
+        self.score_dict = {
+            "not_present" : 0,
+            "wrong_pos" : 1,
+            "right" : 2
+        }
+        self.word_list = get_word_list()
+
+    def check_word(self,ref_word:str)->bool:
+        """
+        Returns True/False based on it's presence.
+        """
+        return ref_word in self.word_list
+    
+    def __call__(self,ref_word:str,pred_word:str)->dict:
+        """
+        Returns the position level score based on the comparison
+        """
+        score_dict = {}
+
+        for letter_idx in range(5):
+            pred_letter = pred_word[letter_idx]
+            if pred_letter == ref_word[letter_idx]:
+                score_dict[pred_letter] = 2
+            elif pred_letter in ref_word:
+                score_dict[pred_letter] = 1
+            else:
+                score_dict[pred_letter] = 0
+
+        return score_dict
+
+if __name__ == "__main__":
+    print(len(get_word_list()))
+    metric = Metrics()
+    print(metric("apple","aplep"))

src/utils.py

@@ -0,0 +1,43 @@
+from itertools import count
+from src.metrics import get_word_list,Metrics
+
+import logging
+import random
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+
+class WordHash:
+    def __init__(self) -> None:
+        self.word_list = get_word_list()
+    
+    def slice_pos(self,pos_letter_pair_list:list)->list:
+        counter = 0
+        tmp = []
+        tmp_super_list =  []
+        for pos_letter_pair in pos_letter_pair_list:
+            pos,letter,flag = pos_letter_pair[0],pos_letter_pair[1],pos_letter_pair[2]
+            if flag == "G":
+                if counter == 0:
+                    for word in self.word_list:
+                        if word[pos] == letter:
+                            tmp.append(word)
+                else:
+                    tmp = [word for word in tmp if word[pos] == letter]
+                counter = counter + 1
+            else:
+                tmp_super_list.append(tmp)
+                if counter == 0:
+                    for word in self.word_list:
+                        if word[pos] == letter:
+                            tmp_super_list[-1].append(word)
+                else:
+                     tmp_super_list[-1] = [word for word in  tmp_super_list[-1] if word[pos] == letter]
+                counter = counter + 1   
+        if len(tmp_super_list) != 0:
+            return [ i for i in tmp_super_list if len(i) > 0]
+        elif len(tmp) != 0 and len(tmp_super_list) == 0:                
+            return [tmp]
+        else:
+            return [self.word_list]