def tests():
#test trie
trie = Trie.Trie()
assert trie.root == {}
#test add: "ate"
assert trie.add("ate") == {
'a': [False, {
't': [False, {
'e': [True, {None}]
}]
}]
}
assert trie.add("atom") == {
'a': [
False, {
't': [
False, {
'e': [True, {None}],
'o': [False, {
'm': [True, {None}]
}]
}
]
}
]
}
print("tests passed")
def __init__(self, parent, *args, **kwargs):
ttk.Frame.__init__(self, parent, *args, **kwargs)
self.root = parent
#Initialize the Trie (dictionary)
self.dictionary = Trie()
#initialize text widget
self.text = Text(self.root, width=100, height=40)
self.text.grid(column=0, row=2)
#Initialize the menu
self.init_gui()
#Bind space and right-click events on the text widget
self.text.bind("<space>", self.spell_check)
self.text.bind('<Button-3>', self.autocorrect)
self.text.bind('<Key>', self.typing_suggestions)
#Initize the filename to empty string
self.filename = ''
#Initialize the underline tag for mispelt words
self.text.tag_configure('underline', foreground='red', underline=True)
#Initialize the highligh tag for found words
self.text.tag_configure('highlight', background='red')
self.text.tag_configure('unhighlight', background='white')
#Initialize pop-up menu for right click
self.pop_menu = tkinter.Menu(parent, tearoff=0)
#Initialize pop-up menu for text statistics
self.pop_stats = tkinter.Menu(parent, tearoff=0)
def creattree():
diclist = opendict()
blendssearch = Trie.Trie()
lendict = len(diclist)
for i in range(lendict):
blendssearch.insert(diclist[i])
return blendssearch
def testAutocomplete_AlmostPrefix_Present_SuggestPartial_2(self):
trie = Trie.Trie()
for word in prefix2:
trie.insert(word, trie.root)
self.assertCountEqual(
Counter(trie.autocomplete("fores")),
Counter(["foreshadow", "foresight", "foreseeable"]))
def visit(self,p,alpha,newEventSet,i,k,Q):
for e in newEventSet:
comparison=False
for child in p.children:
if child.event==e:
comparison=True
if comparison:
if self.debug:
print('Already have')
else:
q=Trie(e,k+1)
p.children.append(q)
if self.debug:
print("New Trie:")
print(p)
print("alpha.events:"+str(alpha.events))
qAlphaPath=alpha.events.copy()
if self.debug:
print("qAlphaPath:"+str(qAlphaPath))
qAlphaPath.append(e)
qAlpha=Episode(qAlphaPath,Window(i,k+1))
Q.add(qAlpha)
if self.debug:
print("New Q:")
for ep in Q:
print(Q)
contained=False
for ep in Q:
if str(ep.events)==str(alpha.events):
contained=True
if contained:
p.isLO=False
if self.debug:
print("P:")
print(p)
def test_complexity(self):
empty_tree = Trie.Trie()
empty_list = []
test_set = create_test_set(100)
tree, list = build(empty_tree, empty_list, 100000)
tree_time = tree_complexity(tree, test_set)
list_time = list_complexity(list, test_set)
self.assertTrue(list_time > tree_time)
def compressao(entrada, saida):
with open(entrada, 'r') as file:
texto = file.read()
trie = Trie.Trie()
arq_saida = open(saida, 'wb')
indice = 0
indice = trie.insert(texto, indice, arq_saida)
file.close()
arq_saida.close()
def main():
keys = parse_file('dictionary.txt')
t = Trie.Trie()
for key in keys:
t.insert(key)
solution(t)
def __init__(self):
self.positives = ["good", "gud", "well", "great", "decent", "amazing", "excellent", "sexy", "superb", "suburb",
"awesome", "awsm", "nice", "happy", "high", "average",
"fast", "quick", "immersing", "immersive", "premium",
"best", "better",
"perfect", "perfection", "beast", "great", "fantastic", "faster", " fabulous", "blazing",
"loved", "love",
"marvellous", "comfortable", "unbeatable"
"charge", "smooth", "beautifully", "beautiful", "superb"]
self.negatives = ["very bad", "bad", "disappointment", "wrong", "never", "slow", "no", "not good", "not work",
"not", "terrible", "heavy"
"issue", "defect", "slowest", "lags", "waste", "doesn't work",
"doesnt work", "doesnt", "doesn't",
"problem", "sucks", "worst",
"pathetic", "not good", "not very good", "ineffective", "poor", "not success"]
self.features = ["phone", "phones", "device", "product", "mobile", "look",
"front camera", "back camera", "rear camera", "camera", "selfie", "front",
"photos", "pictures", "video", "images", "lowlight pictures", "lowlight",
"fingerprint", "fingerprints", "finger print", "finger lock", "fingerlock", "finger", "touch",
"display", "hd", "design", "build", "performance", "gorilla glass", "screen", "super amoled",
"amoled", "notch", "gorrilla glass",
"battery", "backup", "charging", "charge", "charger",
"connectivity", "network",
"face unlock", "face", "face recognition",
"sound", "headset", "headphones", "audio", "speakers", "speaker",
"water resistance", "water",
"notifications light", "notification light",
"adaptive brightness sensor", "sensor", "call quality", "call", "nfc", "wifi", "bluetooth",
"other devices",
"one ui", "one-ui", "ui", "os", "color os", "coloros", "miui",
"pubg", "gaming", "games", "color", "ram", "memory",
"heating", "price", "cost", "value for money", "budget", "affordable",
"processor", "chipset", "cpu", "speed", "bloatware",
"microsd", "micro sd", "storage",
"weight"]
# STOPWORDS
self.stopwords = nltk.corpus.stopwords.words('english')
for pos in self.positives:
if pos in self.stopwords:
self.stopwords.remove(pos)
for neg in self.negatives:
if neg in self.stopwords:
self.stopwords.remove(neg)
for ftr in self.features:
if ftr in self.stopwords:
self.stopwords.remove(ftr)
self.trie = Trie()
for pos in self.positives:
self.trie.insert(pos, 'Positive')
for neg in self.negatives:
self.trie.insert(neg, 'Negative')
for ftr in self.features:
self.trie.insert(ftr, 'Features')
def __init__(self, documentPath, dictionaryFilePath):
# Create Trie to store dictionary words
self.dictionaryTrie = Trie.Trie()
# Create rope structure for document
self.document = None
self.populateDocumentWithInputText(documentPath)
# Insert dictionary words in Trie
for word in self.yieldWords(dictionaryFilePath):
self.dictionaryTrie.insert(word, self.dictionaryTrie.root)
# Create an empty rope object to later store pasted text
self.paste_text = ropes.Rope("")
def testAutocomplete_LongWord_NotPresent_1(self):
trie = Trie.Trie()
for word in prefix1:
trie.insert(word, trie.root)
longEnd = ""
for _ in range(20):
longEnd += chr(
choice([
i for i in range(65, 123) if i not in list(range(91, 97))
]))
self.assertEqual(trie.autocomplete("inter" + longEnd), None)
def testAutocomplete_NotPrefix_Not_Present_5(self):
trie = Trie.Trie()
for word in prefix5:
trie.insert(word, trie.root)
# generates a random letter (uppercase or lower) that is not that of the first letter in the prefix
random_letter = choice([
i for i in range(65, 123) if i not in list(range(91, 97)) +
[ord(prefixes[4][0].upper()),
ord(prefixes[4][0].lower())]
])
self.assertEqual(trie.autocomplete(chr(random_letter)), None)
def test_insertion():
"""Test behavior of trie."""
tree = Trie.Trie()
words = [
"monkey", "monkeybusiness", "banana", "monkey", "bananas", "bananas",
"m"
]
for word in words:
tree.insert(word)
return tree
def test_total_count(self):
t = Trie.Trie()
self.assertEqual(t.total_count(), 0)
t.add_word('wonder')
t.add_word('happy')
t.add_word('beautiful')
self.assertEqual(t.total_count(), 3)
t.add_word('')
self.assertEqual(t.total_count(), 3)
def __init__(self, path=None):
self.path = path
self.lock = Lock()
if path is None:
self.db = sqlite3.connect(p.curdir + "/BlockChain.sqlite3")
self.path = p.curdir + "/BlockChain.sqlite3"
else:
self.db = sqlite3.connect(path)
if os.path.exists("./trie"):
file = io.open("./trie", 'rb')
self.trie = Trie.Trie('$')
id = file.read(11)
while len(id) == 11:
self.trie.insert(id.decode())
id = file.read(11)
file.close()
else:
self.db.cursor().execute("drop table if exists Blocks")
io.open("./trie", 'xb')
self.trie = Trie.Trie('$')
self.tip2 = []
self.init_db()
self.db.close()
def creatreversetree():
dictlist = []
f1 = open("dict.txt", "r")
for words in f1:
if duplicate(words) == 1:
dictwords = words.strip()
dicwords = dictwords[::1]
dictlist.append(dicwords)
f1.close()
research = Trie.Trie()
lendict = len(dictlist)
for i in range(lendict):
research.insert(dictlist[i])
return research
def lexicon_from_file(lexicon_filename):
'''takes a file of words and builds Trie from it.
Note: each word in the list should end with a newline character.
Args: filename (str)
Returns: lexicon (Trie)'''
lexicon = Trie.Trie()
f = open(lexicon_filename, 'r')
p = re.compile('qu')
for line in f:
if re.match('q[^u]', line): continue
lexicon.add_word(p.sub('q', line[:-1]))
return lexicon
def main():
word_lists = [
'words_44k.txt', 'words_109k.txt', 'words_178k.txt', 'words_263k.list',
'words_370k.txt'
]
# insert
print("Insertion:\n")
insert_times = []
counter = 1
for file in word_lists:
print("Processing file " + str(counter))
f_read = open('word_list/' + file)
T = Trie()
start = time.time()
for word in f_read.readlines():
T.insert(word.rstrip())
endtime = time.time() - start
print(endtime)
insert_times.append(endtime)
f_read.close()
counter += 1
f_write_insertradix = open('data/trie_insert.txt', 'w')
for timetaken in insert_times:
f_write_insertradix.write(str(timetaken) + '\n')
f_write_insertradix.close()
# search
print("\nSearch:\n")
word_searches = [
'to', 'unappeasableness', 'pseudopseudohypoparathyroidism',
'hippopotomonstrosesquippedaliophobia',
'pneumonoultramicroscopicsilicovolcanoconiosis'
]
counter = 1
search_times = []
for word in word_searches:
print("Processing word " + str(counter))
start = time.time()
T.search(word)
endtime = time.time() - start
print(endtime)
search_times.append(endtime)
counter += 1
f_write_searchradix = open('data/trie_search.txt', 'w')
for timetaken in search_times:
f_write_searchradix.write(str(timetaken) + '\n')
f_write_searchradix.close()
def __init__(self, document):
self.textLength = len(document)
self.original = document
self.buffer = ""
self.pieces = [Piece(False, 0, len(document))]
self.dictionary = Trie.Trie()
# On windows, the dictionary can often be found at:
# C:/Users/{username}/AppData/Roaming/Microsoft/Spelling/en-US/default.dic
with open(
"C:/Users/kirti/AppData/Roaming/Microsoft/Spelling/en-US/default.dic"
) as input_dictionary:
for line in input_dictionary:
words = line.strip().split(" ")
for word in words:
self.dictionary.insert(word.lower())
self.pasteText = ""
def main():
my_trie = Trie()
file = open('text.txt', 'r')
word = ''
line_c = 1
for line in file:
col_c = 1
for ch in line:
if ch.isalpha():
word += ch
elif len(word) > 0:
my_trie.insert(word, (line_c, col_c))
word = ''
col_c += 1
line_c += 1
file.close()
print(my_trie.search('the'))
print(my_trie.match_prefix('se'))
def suggestions():
# Receiveing the parameters from the GET request
queryParams = request.args.get('q')
if queryParams == "":
return 'null'
# Creating a Trie object
trie = Trie()
# Creating a Full Trie from the corpus received
sentences = service_data
for sentence in sentences:
trie.addSentence(sentence)
# Getting the list of suggestions by supplying query
result = trie.generate_completions(queryParams)
return jsonify(Completions=result)
def _generateTriesByNeedOneDirection(self, clueSpots, ds, tries={}):
for direction, row, col in clueSpots:
pair = (row, col)
wordCoordinates, length = self.coordWord(pair, direction)
infoInTable = self.wordInfo(wordCoordinates)
orderOfTrie, allPermanent = self.orderOfTrie(wordCoordinates)
if (length, orderOfTrie) in tries:
continue
else:
dictionaryOfWordOfRightLength = ds[length - 3]
trieMadeTheRightWay = Trie.Trie(None)
# TAKES A LOT OF TIME!
for word in dictionaryOfWordOfRightLength:
wordAltered = Board_helper.putWordIntoCustomizedOrder(
word, orderOfTrie)
trieMadeTheRightWay = trieMadeTheRightWay.addWord(
wordAltered)
tries[(length, orderOfTrie)] = trieMadeTheRightWay
return tries
def add_from_text(text, word_length, trie=None):
"""Adds all substrings of text with specified length to a trie.
If no trie is specified, an empty one is first created.
Args:
text: A string from which the words to add to the trie are formed.
word_length: Integer specifying length of the substrings of text.
trie: A trie (Trie.Trie). Optional. If not specified an empty one is created.
Returns:
A trie (Trie.Trie).
"""
if trie is None:
trie = Trie.Trie()
trie.feed_text(text, word_length)
return trie
def test_random_word(self):
t = Trie.Trie()
t.add_word('wonky')
random_word = t.random_word(3)
self.assertIsInstance(random_word, str)
self.assertEqual(len(random_word), 3)
self.assertIsNone(t.random_word(100))
t.add_word('toaster')
t.add_word('care bear')
t.add_word('croakamancer')
prefix = 'toa'
for counter in range(10):
prefixed_word = t.random_word(5, prefix=prefix)
self.assertSequenceEqual(prefixed_word[:len(prefix)],
prefix,
seq_type=str)
def Implement_Trie_Loop(ope, params):
if len(ope) <= 0 or len(params) <= 0:
return
if len(ope) != len(params):
return
for i in range(len(ope)):
if ope[i] == "Trie":
trie = Trie.Trie()
print("Trie()")
elif ope[i] == "insert":
trie.insert(params[i])
print("Trie.insert({0})".format(params[i]))
elif ope[i] == "search":
res = trie.search(params[i])
print("Trie.search({0}) ... {1}".format(params[i], res))
elif ope[i] == "startsWith":
res = trie.startsWith(params[i])
print("Trie.startsWith({0}) ... {1}".format(params[i], res))
def add_from_gutenberg(urls, word_length, trie=None):
"""Adds substrings from Project Gutenberg text to a trie.
Takes URLs for a Project Gutenberg book and adds all substrings of length
word_length from those texts to a trie. If no trie is supplied, a new one is created.
Args:
urls: A list of URLs to Project Gutenberg text files.
word_length: Integer specifying the length of the substrings to add to the trie.
trie: Optional. A trie (Trie.Trie). If not supplied, an empty trie will be created.
Returns:
A trie (Trie.Trie).
"""
if trie is None:
trie = Trie.Trie()
for url in urls:
response = requests.get(url)
text = clean_gutenberg_txt(response.text)
trie.feed_text(text, word_length)
return trie
def buildTrie(self,newEventSet,k):
root=Trie('0',k+1)
for c in newEventSet:
node=Trie(c,k+1)
root.children.append(node)
return root
# -*- coding: utf-8 -*-
"""
Created on Sun Feb 19 20:09:25 2017
@author: user
"""
import Trie
from words_tagging import all_noun
from Declension import Declension_noun
from Stemming import stem, initialize
mytrie = Trie.Trie()
mytrie = initialize()
if __name__ == '__main__':
correct = 0
incorrect = 0
total = 0
incorrect_words = []
for s_type in all_noun:
for noun in s_type:
dec = Declension_noun(noun)
print(noun)
#print(dec)
for row in dec:
for col in row:
total = total + 1
if stem(col) == noun:
correct = correct + 1
else:
incorrect = incorrect + 1
incorrect_words.append(col)
def __init__(self):
self._trie = my_trie.Trie()
pass
Dictionary._instance = Dictionary()
return Dictionary._instance
def load_dic(self, _file_path):
#todo check the _file_path
with open(_file_path) as _dic_file:
for line in _dic_file:
_word_list = (_word, _nota, _id, _cost,
_tag) = line.rstrip().split("\t")
self._trie.add_item(_nota, (_word_list))
sys.stderr.write("==> load dic finished \n")
def search_exact(self, _key):
return self._trie.search_item(_key)
def search_prefix(self, _key):
return self._trie.search_prefix(_key)
def destory_dict(self):
del self._trie
if __name__ == "__main__":
tri = my_trie.Trie()
diction = Dictionary.get_instance()
diction.load_dic("./dictionary/basic.dic")
print "\t".join(diction.search_exact("ひと"))
for item in diction.search_prefix("わたし"):
print "\t".join(item)
