Durable Drills

.flake8

@@ -1,3 +1,4 @@
+[flake8]
 max-line-length=100
 application_import_names=projectt
 ignore=P102,B311,W503,E226,S311,W504,F821

.gitignore

@@ -102,3 +102,6 @@ venv.bak/
 
 # mypy
 .mypy_cache/
+
+# Ignores for Pycharm Interpreter
+.idea/

Pipfile

@@ -12,4 +12,5 @@ flake8 = "*"
 python_version = "3.7"
 
 [scripts]
-lint = "python -m flake8"
+start = "python -m project"
+lint = "python -m flake8"

README.md

@@ -30,16 +30,26 @@ You should be using [Pipenv](https://pipenv.readthedocs.io/en/latest/). Take a l
 
 # Project Information
 
-`# TODO`
+Team: Durable Drills
 
 ## Description
 
-`# TODO`
+Keep track of your contact information using the Durable Drills Contact Manager™. 
 
 ## Setup & Installation
 
-`# TODO`
+Assuming you are using pipenv, "pipenv run start" should make the program work!
 
 ## How do I use this thing?
 
-`# TODO`
+Using the Contact Manager is simple:
+  - To load in your current contacts, press 'Load Contacts' in the 'View Contacts' tab
+  - To save your current list of contacts, press 'Save Contacts'
+  - To view the information of a specific contact, select that contact and press 'Show Info', then spin the Wheel™ to determine what info you can see
+  - To delete a specific contact, select that contact then press 'Delete'
+
+  - To create a new contact, go to the 'New Contact' tab and enter your contacts information:
+    - For text entries, like the contact Name, Address, Email, and Notes, answer the questions provided by the EntryBot3000™
+    - For numerical entries, like the Phone Number, use the provided rotary phone, then select the type of phone number: Personal, Work, or Home.
+    - For all entries, you need to press the accompanying 'Add' button to add that information to the preview window; when the preview looks the way you want it, press 'Submit to Contacts'.
+    - To clear all entries, press 'Clear'

project/AlphabetGuesser/AlphabetGuesserInter.py

@@ -0,0 +1,156 @@
+import tkinter as tk
+from tkinter import N, S, E, W
+from random import randint
+from project.AlphabetGuesser.letter_guesser import LetterGuesser
+
+
+class AlphabetGuesserInter(tk.Frame):
+
+    def __init__(self, master, current_entry, *args, **kwargs):
+        super().__init__(master, *args, **kwargs)
+        self.master = master
+        self.letter_guesser = LetterGuesser()
+
+        self.current_entry = current_entry
+        self.current_entry_label = None
+        self.letters_input = None
+        self.header = None
+        self.description = None
+        self.title_label = None
+        self.current_letter_id = 1
+        self.question_label = None
+        self.current_word = None
+        self.button_1 = None
+        self.button_2 = None
+        self.submit_button = None
+
+        self.__letter_found = False
+
+        self.create()
+
+    def create(self):
+        self.header = tk.Label(self, text="EntryBot 3000", font="Calibri 20")
+        self.description = tk.Label(self, text="The latest in typing technology since 700 B.C\n\n",
+                                    font="Calibri 10")
+
+        self.title_label = tk.Label(self,
+                                    text="You are entering {} {}:\nAnswer the questions below to"
+                                         "fill out the entry\n"
+                                    .format(self.get_prefix(self.current_entry),
+                                            self.current_entry),
+                                    font="Calibri 11")
+        self.question_label = tk.Label(self,
+                                       text="Is your {} character contained in the phrase :"
+                                            "".format(self.complete_number(self.current_letter_id)),
+                                       font="Calibri 11")
+
+        self.current_word = tk.Label(self, font="Calibri 18", relief="sunken")
+        self.update_current_asked_word()
+
+        self.button_1 = tk.Button(self, command=lambda: self.send_answer(self.button_1['text']))
+        self.button_2 = tk.Button(self, command=lambda: self.send_answer(self.button_2['text']))
+        self.button_1.config(font="Calibri 15")
+        self.button_2.config(font="Calibri 15")
+        self.randomize_buttons()
+
+        self.current_entry_label = tk.Label(self, text=self.current_entry + " :", font="Calibri 12")
+        self.letters_input = tk.Label(self, relief="sunken", font="Calibri 15")
+
+        self.submit_button = tk.Button(self, text="Submit", font="Calibri 15",
+                                       command=lambda: self.submit())
+
+        self.header.grid(row=0, column=0, columnspan=2, sticky=N + S + E + W)
+        self.description.grid(row=1, column=0, columnspan=2, sticky=N + S + E + W)
+
+        self.title_label.grid(column=0, row=2, columnspan=2, sticky=N + S + E + W)
+        self.question_label.grid(column=0, row=3, columnspan=2, sticky=N + S + E + W)
+        self.current_word.grid(column=0, row=4, columnspan=2, padx=10, pady=10,
+                               sticky=N + S + E + W)
+
+        self.button_1.grid(column=0, row=5, sticky=N + S + E + W)
+        self.button_2.grid(column=1, row=5, sticky=N + S + E + W)
+
+        self.current_entry_label.grid(column=0, row=6, columnspan=2, sticky=N + S + E + W)
+        self.letters_input.grid(column=0, row=7, columnspan=2, padx=10, sticky=N + S + E + W)
+        self.submit_button.grid(column=0, row=8, columnspan=2, padx=10, pady=10,
+                                sticky=N + S + E + W)
+
+        self.grid(row=0, column=0)
+
+    def update_current_asked_word(self):
+        self.current_word['text'] = '"' + self.letter_guesser.request_word() + '"'
+
+    def send_answer(self, answer):
+        if self.__letter_found and answer == "Yes":
+            self.current_letter_id += 1
+            if self.question_label['text'] == "I found your character! Continue?":
+                self.question_label['text'] = "Is your {} character contained in the phrase :"\
+                    "".format(self.complete_number(self.current_letter_id))
+            self.restart_letter_guesser()
+            return
+        elif self.__letter_found and answer == "No":
+            # Return the current output and go back to the main window
+            self.submit()
+            return
+        self.letter_guesser.answer(self.current_word['text'], answer)
+        self.randomize_buttons()
+
+        print(self.letter_guesser.possible_characters)
+        if len(self.letter_guesser.possible_characters) == 1:
+            self.letter_found()
+        else:
+            self.update_current_asked_word()
+
+    def letter_found(self):
+        self.question_label['text'] = "I found your character! Continue?"
+        self.current_word['text'] = self.letter_guesser.possible_characters[0].upper()
+        if len(self.letters_input['text']) == 0 or self.letters_input['text'][-1] == " ":
+            self.letters_input['text'] += self.letter_guesser.possible_characters[0].upper()
+        else:
+            self.letters_input['text'] += self.letter_guesser.possible_characters[0]
+        self.__letter_found = True
+
+    def randomize_buttons(self):
+        if randint(0, 1) == 1:
+            self.button_1['text'] = 'Yes'
+            self.button_2['text'] = 'No'
+        else:
+            self.button_1['text'] = 'No'
+            self.button_2['text'] = 'Yes'
+
+    def get_answer(self):
+        return self.letters_input['text']
+
+    def submit(self):
+        self.master.event_generate("<<Info Submitted>>")
+        print("Submitted")
+
+    @staticmethod
+    def get_prefix(word):
+        if word[0] in ['A', 'E', 'I', 'O', 'U']:
+            return 'an'
+        return 'a'
+
+    @staticmethod
+    def complete_number(number):
+        if number == 1:
+            return '1st'
+        elif number == 2:
+            return '2nd'
+        elif number == 3:
+            return '3rd'
+        else:
+            return str(number) + 'th'
+
+    def restart_letter_guesser(self):
+        self.letter_guesser.__init__()
+        self.update_current_asked_word()
+        self.__letter_found = False
+
+
+if __name__ == '__main__':
+    root = tk.Tk()
+    root.geometry("300x400")
+    root.resizable(False, False)
+    a = AlphabetGuesserInter(root, "Name", width=300, height=500)
+    root.mainloop()

project/AlphabetGuesser/create_dictionary.py

@@ -0,0 +1,30 @@
+import pickle
+
+
+def create_dictionary() -> None:
+    """
+    Reads each word from a file with the format of words.txt & determines what letters comprise each
+        word; saved into a dictionary in the following format:
+        {'apple': [a, e, l, p], 'banana': [a, b, n], ...etc}
+        Finally, the created dictionary is saved as a pickle
+    :return: None
+    """
+    dictionary = {}
+    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
+                'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+                '8', '9', '@', '.', '-', ' ', '?', '!']
+    with open('project/Alphabetguesser/words.txt') as f:
+        for word in f:
+            word = word[:len(word) - 1]
+            letters = []
+            for letter in alphabet:
+                if letter in word:
+                    letters.append(letter)
+            dictionary[word] = letters
+        f.close()
+    with open("project/AlphabetGuesser/words_pickle", 'wb') as outfile:
+        pickle.dump(dictionary, outfile)
+
+
+if __name__ == '__main__':
+    create_dictionary()

project/AlphabetGuesser/letter_guesser.py

@@ -0,0 +1,115 @@
+import pickle
+import random
+
+
+class LetterGuesser:
+    """
+    LetterGuesser:
+
+    === Public Attributes ===
+    dictionary
+    possible_characters
+
+    === Methods === request_word: returns a random word from the dictionary
+    remove_possible_letters: removes all characters from possible_characters that are not
+        contained in the given word/phrase remove_possible_words: removes all words/phrases from
+        dictionary that contain none of the characters in the given word/phrase
+    contains_none_letters: Returns True only if none the letters in word_2 are contained in  word_1
+    answer: Handles the user's answer of either "Yes" or "No"
+    """
+    def __init__(self):
+        self.dictionary = None
+        self.possible_characters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                                    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '@', '.', '-',
+                                    ' ', '?', '!']
+        with open("project/alphabetguesser/words_pickle", "rb") as openfile:
+            self.dictionary = pickle.load(openfile)
+            openfile.close()
+
+    def answer(self, requested_word, answer):
+        """
+        Handles the user's answer for a given word
+        :param requested_word: The context of the user's answer
+        :param answer: string that should be either "Yes" or "No"; the program will  not respond to
+            anything else
+        :return: None
+        """
+        self.remove_possible_letters(requested_word, answer)
+        self.remove_possible_words()
+
+    def request_word(self) -> str:
+        words = list(self.dictionary.keys())
+        random.shuffle(words)
+        for word in words:
+            if self.find_ratio_of_remaining_letter_in_word(word) > 30:
+                return word
+        return random.choice(words)
+
+    def remove_possible_letters(self, word, answer) -> None:
+        characters_to_delete = []
+        for character in self.possible_characters:
+            if character not in word and answer == "Yes":
+                characters_to_delete.append(character)
+            elif character in word and answer == "No":
+                characters_to_delete.append(character)
+        for character in characters_to_delete:
+            self.possible_characters.remove(character)
+
+    def remove_possible_words(self) -> None:
+        words_to_delete = []
+        for elem in self.dictionary:
+            if self.contains_none_letters(elem, self.possible_characters) or \
+                    self.contains_all_letters(self.possible_characters, elem):
+                words_to_delete.append(elem)
+            # if a word contains none of the possible letters, remove it
+        for elem in words_to_delete:
+            del self.dictionary[elem]
+
+    def find_ratio_of_remaining_letter_in_word(self, word):
+        i = 0
+        for letter in self.possible_characters:
+            if letter in word:
+                i += 1
+
+        return i/len(word)*100
+
+    @staticmethod
+    def contains_none_letters(word_1, word_2) -> bool:
+        for letter in word_1:
+            if letter in word_2:
+                return False
+        return True
+
+    @staticmethod
+    def contains_all_letters(word_1, word_2) -> bool:
+        for letter in word_1:
+            if letter not in word_2:
+                return False
+        return True
+
+
+if __name__ == '__main__':
+    """
+    This is a simple demo showing how the letter guesser should be implemented
+    """
+
+    guesser = LetterGuesser()
+    question_num = 1
+    print('Pick a character, any character; keep it in mind as you answer these questions!\n')
+    while True:
+        word = guesser.request_word()
+        yes_no = input('Question #{0}:\nIs your character in the word/phrase:\n{1}\n(Yes/No):'
+                       .format(question_num, word))
+        if yes_no == "Quit":
+            break
+        question_num += 1
+        guesser.answer(word, yes_no)
+        print('Possible characters:', guesser.possible_characters)
+        print('Words left to pick from:', len(list(guesser.dictionary)))
+        if len(guesser.possible_characters) == 1:
+            print('The character you want is \'{0}\''.format(guesser.possible_characters[0]))
+            break
+        if len(guesser.possible_characters) < 1:
+            print('A mistake has been made; try again')
+            break