Caesar Cipher

import string


def load_words(file_name):
    '''
    file_name (string): the name of the file containing 
    the list of words to load    
    
    Returns: a list of valid words. Words are strings of lowercase letters.
    
    Depending on the size of the word list, this function may
    take a while to finish.
    '''
    print('Loading word list from file...')
    # inFile: file
    in_file = open(file_name, 'r')
    # line: string
    line = in_file.readline()
    # word_list: list of strings
    word_list = line.split()
    print('  ', len(word_list), 'words loaded.')
    in_file.close()
    return word_list


def is_word(word_list, word):
    '''
    Determines if word is a valid word, ignoring
    capitalization and punctuation
    '''
    word = word.lower()
    word = word.strip(" !@#$%^&*()-_+={}[]|\:;'<>?,./\"")
    return word in word_list
    
def get_story_string():
    """
    Returns: a joke in encrypted text.
    """
    f = open("story.txt", "r")
    story = str(f.read())
    f.close()
    return story

WORDLIST_FILENAME = 'words.txt'

class Message(object):
    def __init__(self, text):

        self.message_text = text
        self.valid_words = load_words(WORDLIST_FILENAME)


    def get_message_text(self):

        return self.message_text

    def get_valid_words(self):
        return self.valid_words[:]
        
    def build_shift_dict(self, shift):
        '''
        Creates a dictionary that can be used to apply a cipher to a letter.
        The dictionary maps every uppercase and lowercase letter to a
        character shifted down the alphabet by the input shift. The dictionary
        should have 52 keys of all the uppercase letters and all the lowercase
        letters only.        
        
        shift (integer): the amount by which to shift every letter of the 
        alphabet. 0 <= shift < 26

        Returns: a dictionary mapping a letter (string) to 
                 another letter (string). 
        '''
        alph = string.ascii_lowercase + string.ascii_uppercase
        shift_dict = {}
        for char in alph:
            shift_dict[char] = ord(char)
        for k, v in shift_dict.items():
            if 65 <= v <= 90:
                nv = v + shift
                if nv > 90:
                    nv = nv - 26
            if 97 <= v <= 122:
                nv = v + shift
                if nv > 122:
                    nv = nv - 26 
            shift_dict[k] = chr(nv)
        return shift_dict

    def apply_shift(self, shift):
        '''
        Applies the Caesar Cipher to self.message_text with the input shift.
        Creates a new string that is self.message_text shifted down the
        alphabet by some number of characters determined by the input shift        
        
        shift (integer): the shift with which to encrypt the message.
        0 <= shift < 26

        Returns: the message text (string) in which every character is shifted
             down the alphabet by the input shift
        '''
        d = Message.build_shift_dict(self, shift)
        l = []
        if 0 <= shift < 26:
            for el in list(Message.get_message_text(self)):
                if el in d:
                    el = d[el]
                    l.append(el)
                else:
                    l.append(el)
        if shift > 26:
            shift = shift % 26
        return ''.join(l)

class PlaintextMessage(Message):
    def __init__(self, text, shift):
        '''
        Initializes a PlaintextMessage object        
        
        text (string): the message's text
        shift (integer): the shift associated with this message

        '''
        Message.__init__(self, text)
        self.shift = shift
        self.encrypting_dict = self.build_shift_dict(shift)
        self.message_text_encrypted = self.apply_shift(shift)
        
    def get_shift(self):

        return self.shift
        
    def get_encrypting_dict(self):

        return self.encrypting_dict.copy()

    def get_message_text_encrypted(self):

        return self.message_text_encrypted

    def change_shift(self, shift):

        self.shift = shift
        self.encrypting_dict = self.build_shift_dict(shift)
        self.message_text_encrypted = self.apply_shift(shift)


class CiphertextMessage(Message):
    def __init__(self, text):

        Message.__init__(self, text)

    def decrypt_message(self):

        text = Message.get_message_text(self)
        tt = text.split()
        result = {}
        f = load_words('words.txt')
        for shift in range(0, 26):
            for elem in tt:
                decryptedMessage = Message.apply_shift(self, shift)
                result[decryptedMessage] = shift
        if shift > 26:
            shift = shift % 26
            result[decryptedMessage] = shift
        for k, v in result.items():
            count = 0
            x = k.split()
            for word in x:
                if is_word(f, word) is True:
                    count += 1
                    if count > len(x)/2:
                        return (result[k], ' '.join(x))

    def decrypt_story(self):

        joke = get_story_string()
        decr = CiphertextMessage(joke)
        return decr.decrypt_message()