If statement not being reached

I am trying to build a function that will evaluate a players guess on line 160. It takes in a guess from an input statement that the player enters after they have seen the game board. The issue that I am running into is that the elif statement on line 173 never runs.

What have I tried and what am I expecting?
I am expecting that when a player types in a game word which is shown when you run the program that one of the if statements will run. Right now the only two that are working is when the player makes a correct choice and when the player picks something that is NOT an option.

Looking at the print statements and what I am working with game_word_set is a list of game words that includes the password. However when I run the print statement it shows an empty list. Why is this?

import sys
import random

basically game_words is where I am telling python to grab the 15 words used fo the hacking mini game.

Players select from this list of words hoping to guess the password.

I need 3 words that have 0 letters in common with the password
and another 3 words that have 1,2,3,4 letters in common with the password respectivley and the password all stored in a way that python can know about it.
after that I need to make a game board that will display the characters and the words on the screen.
# -----------------------------------------------------------------#

# garbage characters system
garbage_chars = "~!@#$%^&*()_+-={}[]|;:,.<>?/"

def introduce():
    name = input("To start the game please type in your player name: ")
        f"Agent {name}! The evil dictator Kim Jong Un has decided to launch the nukes. All of humanity's hopes rest on your shoulders to hack into the system and stop the launch. You will see a series of possible words that are the password. Use our hint system software to determine if you are close to guessing the password. The hint system will tell you the letters that the word choice and the password have in common as well as positioning. You are our last hope.... \n Okay agent {name}, here are list of the possible passwords. \n Type in the word from the available list of words that you believe is the password."
    return name

# this function will gather in the game words from the sevenletterwords.txt file and be returned in this function.
def get_word_list():
    with open("sevenletterwords.txt", "r") as file:
        word_list = [line.strip().upper() for line in file.readlines()]
        # test print(full_list_of_words)
    return word_list

# This function generates a password for the player to guess.
def get_password(word_list):
    password = random.choice(word_list)
    # print("test: This is a test for the password: ", password)
    return password

# From the word list we need game words that have a certain number of letters in common with the password.
# in this case we sum up the dictionaries values and put them into a list.
# after that the password is appended to the list.

def get_game_word_set(word_list, password):
    game_words_dictionary = {}
    game_words = []
    # we can target keys in a dictionary with variables!
    # I want to use this technique once I get all three of them in there.
    # place the words that have 0 letters in common into the dictionary at the 0 index.
    game_words_dictionary[0] = get_n_overlap(word_list, 0, password)
    # now do the same things for the other words
    game_words_dictionary[1] = get_n_overlap(word_list, 1, password)
    game_words_dictionary[2] = get_n_overlap(word_list, 2, password)
    game_words_dictionary[3] = get_n_overlap(word_list, 3, password)
    game_words_dictionary[4] = get_n_overlap(word_list, 4, password)
    # now we combine these values in the dictionary togather into a single list.
    game_word_set = sum(game_words_dictionary.values(), [])
    print("This is the game words dictionary. \n" + str(game_word_set))
    print("This is the password for the game. \n" + str(password))
    return game_word_set

# the game words need to have a certain amount of characters in common with the password.
# in this function x will hold the number of words that will be generated with each functionc call.
# so if this funciton is called once than three words will generate.
def get_n_overlap(word_list, n, password):
    overlapping_words = []
    x = 0
    for word in word_list:
        if x < 3:
            # if the number of matching letters is the same as n than append that word to the list.
            overlap = set(password) & set(word)
            if len(overlap) == n and word != password:
                x += 1
                if x == 3:
    return overlapping_words

# in each game row we need a memory address that starts with a hex number.
# this function will generate the hex number. an example is shown below.
# Ox217_ _ _ _ _ _ _ _ _ _ _
def hex_number():
    number = random.randint(1000, 1500)
    hex_number = hex(number)
    return hex_number

# this function will insert the game word at a random place and always after the hex memory number is made first.
# the garbage characters will fill in the rest of the empty spaces.

def garbage_character_filler(game_word):
    character_row_limit = 16
    garbage_row = []
    characters_left = character_row_limit - len(garbage_row[0]) - len(game_word)
    insertion = random.randint(1, characters_left)
    garbage_chars = "~!@#$%^&*()_+-={}[]|;:,.<>?/"
    garbage_row.extend(random.choices(garbage_chars, k=5))
    garbage_row.insert(insertion, game_word)
    game_row = "".join(garbage_row)
    return game_row

# python gotchas with mutable data types workaround
# python needs to be told to iterate past the first game word and to include the other 15 words.
# this function generates a list of the game words in strings with the memory address and hex address and garbage characters.
# an issue I ran into was that using pop modifies the list and results in items being skipped over
# so the keyword and is utilized and word is placed as the variable.

def game_word_selection(game_word_set):
    gamewords = []
    while len(gamewords) < 16 and game_word_set:
        word = game_word_set.pop()
        garbageword = garbage_character_filler(word)
    return gamewords

# def game_word_selection(game_word_set):
#     gamewords = []
#     while len(gamewords) < 16:
#         for word in game_word_set:
#             game_word_set.pop()
#             garbageword = garbage_character_filler(word)
#             gamewords.append(garbageword)
#         return gamewords

# format gamewords functions job is to create two columns for the gamewords and
# rows with two game words and there string designs.

def format_gamewords(game_rows):
    game_string = "".join(game_rows)
    formatted_rows = []

    for i, row in enumerate(game_rows, start=1):
        if i % 2 == 0 and i != len(game_rows):
            formatted_rows.append("\n")  # Add a new line after every two iterations
            formatted_rows.append("     ")  # Add 5 spaces in between each iteration
    game_string = "".join(formatted_rows)

    return game_string

def evaluate_guess(password, game_word_set, name, body_count):
    attempts_left = 3
    states_lost = []

    while attempts_left != 0:
        guess = input("WELCOME SUPREME LEADER PLEASE TYPE THE PASSWORD: ").upper()
        if guess == password:
            # game_word_set has the symbols which means guessing this is impossible. unless i tell them to input the symbols.
        elif guess in game_word_set and guess != password:
            print("\n Oh no! We got it wrong!")
            lost_state = states_lost()
            print("\n We lost the state of {state} in a nuclear explosion!")
            attempts -= 1
            print("\n We have {attempts_left} left")

                f"\n Agent {name}, what are you doing! Thats not one of the words listed! Pick one of the game words listed on screen!"
            print("This is the current guess", guess)
            print("Test for game_word_set", game_word_set)
            print("This is the password", password)

# determine a state, determine a point value, add the states to a dictionary and sum up the totals at the end of the game.

def states_lost():
    states = {}

    small_states = [
        "North Dakota",
        "New Hampshire",
        "New Jersey",
        "Puerto Rico",
        "Rhode Island",
        "South Dakota",
        "Virgin Islands",
        "West Virginia",
    medium_states = [
        "North Carolina",
        "New Mexico",
        "South Carolina",
    important_states = {
        "New York",
        "District ",
        "of Columbia",

def hint_system():

# DRIVER CODE ---------------------
# these lines of code are here to prevent not defined issues.

def main():
    name = introduce()
    word_list = get_word_list()
    password = get_password(word_list)
    # on this line of code we establish the game words to be used for the game session.
    game_word_set = get_game_word_set(word_list, password)
        "This is the output of the get_game_word_set which shows game_word_set \n",
    # we need to determine which game word python will use one at a time without duplicates.
    game_rows = game_word_selection(game_word_set)
    game_rows = format_gamewords(game_rows)
    print("Okay we managed to get into his system! \n")

    state = []
    evaluate_guess(password, game_word_set, name, state)

# If this program was run (instead of imported), run the game:
if __name__ == "__main__":
    except KeyboardInterrupt:
        sys.exit()  # When Ctrl-C is pressed, end the program.
# random will change things in place. there is no need for variables.