diff --git a/AutoComplete_App/backend.py b/AutoComplete_App/backend.py new file mode 100644 index 00000000000..47e1c7906d6 --- /dev/null +++ b/AutoComplete_App/backend.py @@ -0,0 +1,126 @@ +import sqlite3 +import json + +class AutoComplete: + """ + It works by building a `WordMap` that stores words to word-follower-count + ---------------------------- + e.g. To train the following statement: + + It is not enough to just know how tools work and what they worth, + we have got to learn how to use them and to use them well. + And with all these new weapons in your arsenal, we would better + get those profits fired up + + we create the following: + { It: {is:1} + is: {not:1} + not: {enough:1} + enough: {to:1} + to: {just:1, learn:1, use:2} + just: {know:1} + . + . + profits: {fired:1} + fired: {up:1} + } + so the word completion for "to" will be "use". + For optimization, we use another store `WordPrediction` to save the + predictions for each word + """ + + def __init__(self): + """ + Returns - None + Input - None + ---------- + - Initialize database. we use sqlite3 + - Check if the tables exist, if not create them + - maintain a class level access to the database + connection object + """ + self.conn = sqlite3.connect("autocompleteDB.sqlite3", autocommit=True) + cur = self.conn.cursor() + res = cur.execute("SELECT name FROM sqlite_master WHERE name='WordMap'") + tables_exist = res.fetchone() + + if not tables_exist: + self.conn.execute("CREATE TABLE WordMap(name TEXT, value TEXT)") + self.conn.execute('CREATE TABLE WordPrediction (name TEXT, value TEXT)') + cur.execute("INSERT INTO WordMap VALUES (?, ?)", ("wordsmap", "{}",)) + cur.execute("INSERT INTO WordPrediction VALUES (?, ?)", ("predictions", "{}",)) + + def train(self, sentence): + """ + Returns - string + Input - str: a string of words called sentence + ---------- + Trains the sentence. It does this by creating a map of + current words to next words and their counts for each + time the next word appears after the current word + - takes in the sentence and splits it into a list of words + - retrieves the word map and predictions map + - creates the word map and predictions map together + - saves word map and predictions map to the database + """ + cur = self.conn.cursor() + words_list = sentence.split(" ") + + words_map = cur.execute("SELECT value FROM WordMap WHERE name='wordsmap'").fetchone()[0] + words_map = json.loads(words_map) + + predictions = cur.execute("SELECT value FROM WordPrediction WHERE name='predictions'").fetchone()[0] + predictions = json.loads(predictions) + + for idx in range(len(words_list)-1): + curr_word, next_word = words_list[idx], words_list[idx+1] + if curr_word not in words_map: + words_map[curr_word] = {} + if next_word not in words_map[curr_word]: + words_map[curr_word][next_word] = 1 + else: + words_map[curr_word][next_word] += 1 + + # checking the completion word against the next word + if curr_word not in predictions: + predictions[curr_word] = { + 'completion_word': next_word, + 'completion_count': 1 + } + else: + if words_map[curr_word][next_word] > predictions[curr_word]['completion_count']: + predictions[curr_word]['completion_word'] = next_word + predictions[curr_word]['completion_count'] = words_map[curr_word][next_word] + + words_map = json.dumps(words_map) + predictions = json.dumps(predictions) + + cur.execute("UPDATE WordMap SET value = (?) WHERE name='wordsmap'", (words_map,)) + cur.execute("UPDATE WordPrediction SET value = (?) WHERE name='predictions'", (predictions,)) + return("training complete") + + def predict(self, word): + """ + Returns - string + Input - string + ---------- + Returns the completion word of the input word + - takes in a word + - retrieves the predictions map + - returns the completion word of the input word + """ + cur = self.conn.cursor() + predictions = cur.execute("SELECT value FROM WordPrediction WHERE name='predictions'").fetchone()[0] + predictions = json.loads(predictions) + completion_word = predictions[word.lower()]['completion_word'] + return completion_word + + + +if __name__ == "__main__": + input_ = "It is not enough to just know how tools work and what they worth,\ + we have got to learn how to use them and to use them well. And with\ + all these new weapons in your arsenal, we would better get those profits fired up" + ac = AutoComplete() + ac.train(input_) + print(ac.predict("to")) \ No newline at end of file diff --git a/AutoComplete_App/frontend.py b/AutoComplete_App/frontend.py new file mode 100644 index 00000000000..90e576e849e --- /dev/null +++ b/AutoComplete_App/frontend.py @@ -0,0 +1,37 @@ +from tkinter import * +from tkinter import messagebox +import backend + + +def train(): + sentence = train_entry.get() + ac = backend.AutoComplete() + ac.train(sentence) + +def predict_word(): + word = predict_word_entry.get() + ac = backend.AutoComplete() + print(ac.predict(word)) + +if __name__ == "__main__": + root = Tk() + root.title("Input note") + root.geometry('300x300') + + train_label = Label(root, text="Train") + train_label.pack() + train_entry = Entry(root) + train_entry.pack() + + train_button = Button(root, text="train", command=train) + train_button.pack() + + predict_word_label = Label(root, text="Input term to predict") + predict_word_label.pack() + predict_word_entry = Entry(root) + predict_word_entry.pack() + + predict_button = Button(root, text="predict", command=predict_word) + predict_button.pack() + + root.mainloop() \ No newline at end of file