Update wordle_functions.py

wordle_functions.py

@@ -200,9 +200,9 @@ def count_vows_cons(word: str, y_vow = True):
 
     return counts
 
-def get_word_meaning(words_to_rate: list, word_list: list, normalized: bool = True, ascending: bool = False):
+def get_word_rating(words_to_rate: list, word_list: list, normalized: bool = True, ascending: bool = False):
     """
-    Given a word and a word list, calculates meaning each word as a measure of its impact to the next possible guesses in Wordle, ordered according to `reverse` parameter.
+    Given a word and a word list, calculates rating each word as a measure of its impact to the next possible guesses in Wordle, ordered according to `reverse` parameter.
     
     ------
     Parameters:
@@ -393,15 +393,15 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
     stats_dict['target_vowels'] = float(count_vows_cons(target, y_vow = True)['vows'])
     stats_dict['target_consonants'] = float(count_vows_cons(target, y_vow = True)['cons'])
     
-    # get meaning of the first guess word and target word in the entire word_list
-    for tup in get_word_meaning(word_list, word_list, normalized = True):
+    # get rating of the first guess word and target word in the entire word_list
+    for tup in get_word_rating(word_list, word_list, normalized = True):
         if tup[0] == guess:
-            stats_dict['first_guess_meaning'] = tup[1]
+            stats_dict['first_guess_rating'] = tup[1]
         if tup[0] == target:
-            stats_dict['target_meaning'] = tup[1]
+            stats_dict['target_rating'] = tup[1]
 
     guess_entropies = []
-    guess_entropies.append(stats_dict['first_guess_meaning'])
+    guess_entropies.append(stats_dict['first_guess_rating'])
 
     # luck_guess_1 = round(1 - ((1 / len(word_list)) * guess_entropies[0] / 100), 2) * 100
 
@@ -654,13 +654,13 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
                     st.write(f"The only remaining possible word is:\n\t'{list(potential_next_guesses)[0]}'\n")
                 
             guess = list(potential_next_guesses)[0]
-            guess_entropies.append(get_word_meaning([guess], word_list, normalized = False, ascending = False)[0][1])
+            guess_entropies.append(get_word_rating([guess], word_list, normalized = False, ascending = False)[0][1])
 
         else:
 
             best_next_guesses = list(potential_next_guesses)                
             # print (best_next_guesses)
-            word_ratings = get_word_meaning(best_next_guesses, word_list, normalized = False, ascending = False) # "internal" ratings
+            word_ratings = get_word_rating(best_next_guesses, word_list, normalized = False, ascending = False) # "internal" ratings
             
             # Get max rating of all words
             max_rating = -np.inf
@@ -668,7 +668,7 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
                 if rating > max_rating:
                     max_rating = rating
 
-            # add best rated words (all equally best meaning in next guess list) to set
+            # add best rated words (all equally best rating in next guess list) to set
             best_of_the_best_1 = []
             for word, rating in word_ratings:
                 if rating == max_rating:
@@ -691,7 +691,7 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
             else:
                 guess = best_of_the_best_1[0] # they're all equally the best of the best possible guesses so just pick the first
             
-            # guess_entropies.append(get_word_meaning([guess], word_list, normalized = False, ascending = False)[0][1])
+            # guess_entropies.append(get_word_rating([guess], word_list, normalized = False, ascending = False)[0][1])
 
             if return_stats == False:
                 if verbose == True:
@@ -702,7 +702,7 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
                         st.write(f"The top 40 potential next guesses are:\n\t{word_ratings[:40]}\n")
                         st.write(f"Words guessed so far:\n\t{guessed_words}.\n")
 
-            guess_entropies.append(get_word_meaning([guess], word_list, normalized = False, ascending = False)[0][1])
+            guess_entropies.append(get_word_rating([guess], word_list, normalized = False, ascending = False)[0][1])
 
         #### Guess has now been made -- what to do next
         if guess_num == max_guesses: # if at max guesses allowed
@@ -771,22 +771,22 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
     # average number of words remaining after each guess -- the higher this is, the luckier the person got (the lower, the more guesses it took)
     stats_dict['avg_remaining'] = float(round(np.mean(reduction_per_guess), 2))
 
-    # avg meaning of each guessed word relative to all other words possible at that moment -- this should consistently be 100 for the algorithm, but will be different for user
+    # avg rating of each guessed word relative to all other words possible at that moment -- this should consistently be 100 for the algorithm, but will be different for user
     if len(guess_entropies) > 1: # in case of guessing it correctly on the first try
         sum_entropies = 0
-        for meaning in guess_entropies:
-            sum_entropies += meaning
+        for rating in guess_entropies:
+            sum_entropies += rating
 
-        average_meaning = float(round(sum_entropies / len(guess_entropies), 2))
-        stats_dict['avg_intermediate_guess_meaning'] = average_meaning
+        average_rating = float(round(sum_entropies / len(guess_entropies), 2))
+        stats_dict['avg_intermediate_guess_rating'] = average_rating
     else:
-        stats_dict['avg_intermediate_guess_meaning'] = float(100)
+        stats_dict['avg_intermediate_guess_rating'] = float(100)
 
     expected_guesses = 3.85
 
     # guess_num = 3
-    # average_meaning = 95
-    luck = round(1 - ((((guess_num / expected_guesses) * (stats_dict['avg_intermediate_guess_meaning'] / 100)) / max_guesses) * 5), 2)
+    # average_rating = 95
+    luck = round(1 - ((((guess_num / expected_guesses) * (stats_dict['avg_intermediate_guess_rating'] / 100)) / max_guesses) * 5), 2)
     stats_dict['luck'] = luck
 
     if record == True:
@@ -915,15 +915,15 @@ def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "st
 #     stats_dict['target_vowels'] = float(count_vows_cons(target, y_vow = True)['vows'])
 #     stats_dict['target_consonants'] = float(count_vows_cons(target, y_vow = True)['cons'])
     
-#     # get meaning of the first guess word and target word in the entire word_list
-#     for tup in get_word_meaning(word_list, word_list, normalized = True):
+#     # get rating of the first guess word and target word in the entire word_list
+#     for tup in get_word_rating(word_list, word_list, normalized = True):
 #         if tup[0] == guess:
-#             stats_dict['first_guess_meaning'] = tup[1]
+#             stats_dict['first_guess_rating'] = tup[1]
 #         if tup[0] == target:
-#             stats_dict['target_meaning'] = tup[1]
+#             stats_dict['target_rating'] = tup[1]
 
 #     guess_entropies = []
-#     guess_entropies.append(stats_dict['first_guess_meaning'])
+#     guess_entropies.append(stats_dict['first_guess_rating'])
 
 #     english_alphabet = "abcdefghijklmnopqrstuvwxyz"
 
@@ -1172,18 +1172,18 @@ def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "st
 #             del guess_list[0]
 #             # print (guess_list)
 #             guess = guess_list[0]
-#             guess_entropies.append(get_word_meaning([guess], word_list, normalized = True, ascending = False)[0][1])
+#             guess_entropies.append(get_word_rating([guess], word_list, normalized = True, ascending = False)[0][1])
 
 #         else:
             
 #             best_next_guesses = list(potential_next_guesses)                
-#             word_ratings = get_word_meaning(best_next_guesses, word_list, normalized = True, ascending = False) # "internal" ratings
+#             word_ratings = get_word_rating(best_next_guesses, word_list, normalized = True, ascending = False) # "internal" ratings
 
 #             del guess_list[0]
 #             # print (guess_list)
 #             guess = guess_list[0]
 
-#             guess_entropies.append(get_word_meaning([guess], word_list, normalized = True, ascending = False)[0][1])
+#             guess_entropies.append(get_word_rating([guess], word_list, normalized = True, ascending = False)[0][1])
 
 #             if return_stats == False:
 #                 if verbose == True:
@@ -1278,16 +1278,16 @@ def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "st
 #     # average number of words remaining after each guess -- the higher this is, the luckier the person got (the lower, the more guesses it took)
 #     stats_dict['avg_remaining'] = float(round(np.mean(reduction_per_guess), 2))
 
-#     # avg meaning of each guessed word relative to all other words possible at that moment -- this should consistently be 100 for the algorithm, but will be different for user
+#     # avg rating of each guessed word relative to all other words possible at that moment -- this should consistently be 100 for the algorithm, but will be different for user
 #     if len(guess_entropies) > 1: # in case of guessing it correctly on the first try
 #         sum_entropies = 0
-#         for meaning in guess_entropies:
-#             sum_entropies += meaning
+#         for rating in guess_entropies:
+#             sum_entropies += rating
 
-#         average_meaning = float(round(sum_entropies / len(guess_entropies), 2))
-#         stats_dict['avg_intermediate_guess_meaning'] = average_meaning
+#         average_rating = float(round(sum_entropies / len(guess_entropies), 2))
+#         stats_dict['avg_intermediate_guess_rating'] = average_rating
 #     else:
-#         stats_dict['avg_intermediate_guess_meaning'] = float(100)
+#         stats_dict['avg_intermediate_guess_rating'] = float(100)
     
 #     # stats_dict['bias'] = bias
 
@@ -1312,7 +1312,7 @@ def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "st
 #     stats_dict['num_guesses'] = float(guess_num)
 
 #     wizard_dict = wordle_wizard(word_list = word_list, max_guesses = max_guesses, 
-#         guess = first_guess, target = target, bias = 'meaning', 
+#         guess = first_guess, target = target, bias = 'rating', 
 #         random_guess = False, random_target = False, 
 #         verbose = False, drama = 0, return_stats = return_stats, record = False)
     
@@ -1324,8 +1324,8 @@ def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "st
 #     stats_dict['expected_guesses'] = wizard_dict['num_guesses']
 
 #     expected_guesses = wizard_dict['num_guesses']
-#     # stats_dict['luck'] = round((1 - (guess_num / expected_guesses)) * (stats_dict['avg_intermediate_guess_meaning'] / 100), 2)
-#     stats_dict['luck'] = round((1 - ((guess_num / expected_guesses)) * (stats_dict['avg_intermediate_guess_meaning'] / 100)), 2)
+#     # stats_dict['luck'] = round((1 - (guess_num / expected_guesses)) * (stats_dict['avg_intermediate_guess_rating'] / 100), 2)
+#     stats_dict['luck'] = round((1 - ((guess_num / expected_guesses)) * (stats_dict['avg_intermediate_guess_rating'] / 100)), 2)
 
 #     stats_master = {}
 #     for metric, result in stats_dict.items():
@@ -1440,9 +1440,9 @@ def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "st
 
 #     # Re-organizing columns to a more logical order (for viewing)
 #     df_master = df_master[['first_guess', 'target_word', 'player', 'num_guesses', 'expected_guesses', 'luck', 'first_guess_vowels', 'first_guess_consonants',
-#                         'target_vowels', 'target_consonants', 'first_guess_meaning', 'target_meaning',
+#                         'target_vowels', 'target_consonants', 'first_guess_rating', 'target_rating',
 #                         'target_guessed', 'mid_guesses_avg_vows', 'mid_guesses_avg_cons', 'avg_perf_letters',
-#                         'avg_wrong_pos_letters', 'avg_wrong_letters', 'avg_remaining', 'avg_intermediate_guess_meaning',
+#                         'avg_wrong_pos_letters', 'avg_wrong_letters', 'avg_remaining', 'avg_intermediate_guess_rating',
 #                         'valid_success']]
 
 #     # print(excepts)