def test_case_value(self):
letters = Letter.from_raw(test.letters)
grid = Grid(test.grid)
word = Word(grid, letters, Letter.from_raw(test.wordons))
print(word.__repr__())
assert word.value is test.value
def insert(self, key):
if self.root == None:
self.root = Letter(key[0], key[1], key[2])
return
new_node = self._find_node_rec(key[0], self.root)
if new_node.key == key[0]:
return
else:
if new_node.key < key[0]:
new_node.right = Letter(key[0], key[1], key[2])
else:
new_node.left = Letter(key[0], key[1], key[2])
class Id:
def __init__(self):
self.letter = None
self.id = None
self.digit = None
self.name = ''
#Recursive parsing to determine what combination of letters and digits the id is made up of based on string passed in.
#This builds the name for the id
def parse(self, idStr):
length = len(idStr)
if length <= 1:
self.letter = Letter()
self.letter.parse(idStr)
self.name = self.letter.let
elif idStr[length - 1].isalpha:
self.letter = Letter()
self.letter.parse(idStr[length - 1])
self.id = Id()
self.id.parse(idStr[0:length - 1])
self.name = self.id.name + self.letter.let
elif idStr[length - 1].isnumeric():
self.digit = Digit()
self.digit.parse(idStr[length - 1])
self.id = Id()
self.id.parse(idStr[0:length - 1])
self.name = self.id.name + self.digit.dig
#Simple print
def print(self):
print(self.name, end='')
#Used for determining value of the id
def exec(self):
return self.getValue()
#Sets the value and checks if the variable was ever even initialized
def setValue(self, val):
if TokList.getIdValue(self.name) is None:
print('ERROR: Value not initialized')
TokList.setIdValue(self.name, val)
#Gets value of the variable and checks to see if it was even initialized or even given a value
def getValue(self):
if TokList.getIdValue(
self.name) == 'null' or TokList.getIdValue(self.name) is None:
print('ERROR: Value undeclared')
exit()
return int(TokList.getIdValue(self.name))
def insert(self, key):
"""Makes a letter case and puts it in the tree"""
if self.root == None:
self.root = Letter(key[0], key[1], key[2])
return
new_node = self._find_node_rec(key[0], self.root)
if new_node.key == key[0]:
return
else:
if new_node.key < key[0]:
new_node.right = Letter(key[0], key[1], key[2])
else:
new_node.left = Letter(key[0], key[1], key[2])
def decrypt(filename, key, alphabets) : contents = get_contents(filename) # split contents by newline characters? lines = get_lines(contents) output = "" for line in lines : count = 0 for char in line : if (Letter.isLetter(char)): current_alphabet = alphabets[count] repeat_value = find_in_alphabet(char, current_alphabet) char_value = 65 + repeat_value output = output + chr(char_value) count = count + 1 if count > len(alphabets) -1: count = 0 else: output = output + char output = output + "\n" return output
def convert_images_to_letters(img_letters:List[List[np.ndarray]],signal)->List[List[Letter]]:
table=[]
rows_number=len(img_letters)
for r_index,row in enumerate(img_letters):
table.append([])
for letter_img in row:
letter_character: str = " "
if letter_img.min()<=170:
try:
letter_character:str=pytesseract.image_to_string(letter_img, config="--psm 10")[0]
except IndexError:
min = letter_img.min()
gre = letter_img[:, :, 0]
print(letter_character)
letter_character="*"
if letter_character=="=":
letter_character="e"
if letter_character=="|":
letter_character="i"
letter_character=letter_character.lower()
table[r_index].append(Letter(letter_img,letter_character))
signal.emit(100*((r_index+1)/rows_number))
return table
def do_comparisons(file_variable, bst):
"""
-------------------------------------------------------
Retrieves every letter in file_variable from bst. Generates
comparisons in bst objects. Each Letter object in bst contains
the number of comparisons found by searching for that Letter
object in file_variable.
Use: do_comparisons(file_variable, bst)
-------------------------------------------------------
Parameters:
file_variable - the already open file containing data to evaluate (file)
bst - the binary search tree containing 26 Letter objects
to retrieve data from (BST)
Returns:
None
-------------------------------------------------------
"""
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
file_variable.seek(0)
lines = file_variable.readlines()
for line in lines:
for word in line:
for letter in word:
upper_letter = letter.upper()
if upper_letter in ALPHABET:
key = Letter(upper_letter)
val = bst.retrieve(key)
return
def do_comparisons(file_variable, bst):
"""
-------------------------------------------------------
Retrieves every letter in file_variable from bst. Generates
comparisons in bst objects. Each Letter object in bst contains
the number of comparisons found by searching for that Letter
object in file_variable.
Use: do_comparisons(file_variable, bst)
-------------------------------------------------------
Parameters:
file_variable - the already open file containing data to evaluate (file)
bst - the binary search tree containing 26 Letter objects
to retrieve data from (BST)
Returns:
None
-------------------------------------------------------
"""
line = file_variable.readline()
lines = []
while line != "":
line = line.strip()
lines.append(line)
line = file_variable.readline()
for line in lines:
for letter in line:
if letter.isalpha():
temp_letter = Letter(letter.upper())
bst.retrieve(temp_letter)
file_variable.close()
return
def test_case_find(self):
letters = Letter.from_raw(test.letters)
grid = Grid(test.grid)
words = Word.find_all(letters, grid, test.language)
assert len(words) is test.wordcount
assert words[0].__str__() == test.topword
assert words[0].value == test.topvalue
def parse(self, idStr):
length = len(idStr)
if length <= 1:
self.letter = Letter()
self.letter.parse(idStr)
self.name = self.letter.let
elif idStr[length - 1].isalpha:
self.letter = Letter()
self.letter.parse(idStr[length - 1])
self.id = Id()
self.id.parse(idStr[0:length - 1])
self.name = self.id.name + self.letter.let
elif idStr[length - 1].isnumeric():
self.digit = Digit()
self.digit.parse(idStr[length - 1])
self.id = Id()
self.id.parse(idStr[0:length - 1])
self.name = self.id.name + self.digit.dig
def caesar(contents, mod) : output = "" for char in contents: if (Letter.isLetter(char)): curr = Letter(char) cyphered = caesar_cypher(curr, mod) output = output + cyphered else: output = output + char return output
def atbash(contents) : output = "" for char in contents: if (Letter.isLetter(char)): curr = Letter(char) cyphered = atbash_cypher(curr) output = output + cyphered else: output = output + char return output
def encrypt(filename, key, alphabets) : contents = get_contents(filename) lines = get_lines(contents) repeating = [] for line in lines : index = 0 repeat_line = "" for i in range(len(line)) : char = contents[i] if (Letter.isLetter(char)) : repeat_line = repeat_line + key[index % len(key)] index = index + 1 else : repeat_line = repeat_line + char repeating.append(repeat_line) output = "" for line in lines : count = 0 for i in range(len(line)) : target_char = line[i] if (Letter.isLetter(target_char)) : current_alphabet = alphabets[count] index = find_in_alphabet(target_char, default) out = current_alphabet[index] output = output + out count = count + 1 if count > len(alphabets)-1 : count = 0 else : output = output + target_char output = output + "\n" return output
def do_comparisons(file_variable, bst):
"""
-------------------------------------------------------
Retrieves every letter in file_variable from bst. Generates
comparisons in bst objects. Each Letter object in bst contains
the number of comparisons found by searching for that Letter
object in file_variable.
Use: do_comparisons(file_variable, bst)
-------------------------------------------------------
Parameters:
file_variable - the already open file containing data to evaluate (file)
bst - the binary search tree containing 26 Letter objects
to retrieve data from (BST)
Returns:
None
-------------------------------------------------------
"""
line = file_variable.read()
current = bst._root
for i in line:
if i.isalpha():
i = Letter(i.upper())
while current is not None and current._value!=i:
if current._value > i:
current = current._left
elif current._value < i:
current = current._right
current = bst._root
return
def main() :
file = open("Atbash.txt", "r")
contents = file.read()
contents = contents.upper()
output = ""
for char in contents:
if (Letter.isLetter(char)):
curr = Letter(char)
cyphered = atbash_cypher(curr)
output = output + cyphered
else:
output = output + char
print(output)
file.close()
file = open("output.txt", "w")
file.write(output)
file.close()
def main() :
file = open("Caesar.txt", "r")
mod = -3
contents = file.read()
contents = contents.upper()
output = ""
for char in contents:
if (Letter.isLetter(char)):
curr = Letter(char)
cyphered = caesar_cypher(curr, mod)
output = output + cyphered
else:
output = output + char
print(output)
file.close()
file = open("output.txt", "w")
file.write(output)
def do_comparisons(file_variable, bst):
"""
-------------------------------------------------------
Retrieves every letter in file_variable from bst. Generates
comparisons in bst objects. Each Letter object in bst contains
the number of comparisons found by searching for that Letter
object in file_variable.
Use: do_comparisons(file_variable, bst)
-------------------------------------------------------
Parameters:
file_variable - the already open file containing data to evaluate (file)
bst - the binary search tree containing 26 Letter objects
to retrieve data from (BST)
Returns:
None
-------------------------------------------------------
"""
for i in file_variable:
if i.isalpha():
i = i.upper()
i = Letter(i)
bst.retrieve(i)
return
def run(self):
for i in range(min(10, self.count)):
self.result.append(
Letter(self.imap.choose_msg(self.count - i, 'body[]')))
""" ------------------------------------------------------- [program 3] ------------------------------------------------------- Author: Anshul Khatri ID: 193313680 Email: [email protected] Section: CP164 Winter 2020 __updated__ = "2020-03-27" ------------------------------------------------------- """ from functions import letter_table, do_comparisons from Letter import Letter from BST_linked import BST DATA1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" DATA2 = "MFTCJPWADHKNRUYBEIGLOQSVXZ" DATA3 = "ETAOINSHRDLUCMPFYWGBVKJXZQ" fv = open("miserables.txt","r") bst1 = BST() for letter in DATA3: ob = Letter(letter) bst1.insert(ob) do_comparisons(fv, bst1) letter_table(bst1)
def letters(self):
return Letter.from_raw(self.instance['yourLetters'] +
self.instance.get('yourWordons', ''))
def __send(self, letter: Letter):
self.__sock.send(bytes(source=letter.to_str() + "\r\n", encoding="utf8"))
print("-> " + letter.to_short_str(self.gtm()))
self.__log.write("-> " + letter.to_large_str(self.gtm()) + "\r\n")
self.__log.flush()
------------------------------------------------------
"""
start = time.time()
bst1 = BST()
bst2 = BST()
bst3 = BST()
DATA1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
DATA2 = "MFTCJPWADHKNRUYBEIGLOQSVXZ"
DATA3 = "ETAOINSHRDLUCMPFYWGBVKJXZQ"
for i in DATA1:
val = Letter(i)
bst1.insert(val)
for i in DATA2:
val = Letter(i)
bst2.insert(val)
for i in DATA3:
val = Letter(i)
bst3.insert(val)
test_file = open('otoos610.txt', 'r', encoding='utf-8')
test_file = test_file.read()
do_comparisons(test_file, bst1)
total1 = comparison_total(bst1)
do_comparisons(test_file, bst2)
"""
from functions import comparison_total, do_comparisons, \
letter_table
from BST_linked import BST
from Letter import Letter
bst_1 = BST()
bst_2 = BST()
bst_3 = BST()
DATA1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
DATA2 = "MFTCJPWADHKNRUYBEIGLOQSVXZ"
DATA3 = "ETAOINSHRDLUCMPFYWGBVKJXZQ"
for data in DATA1:
letter = Letter(data)
bst_1.insert(letter)
for data in DATA2:
letter = Letter(data)
bst_2.insert(letter)
for data in DATA3:
letter = Letter(data)
bst_3.insert(letter)
fh = open('otoos610.txt', 'r')
do_comparisons(fh, bst_1)
do_comparisons(fh, bst_2)
do_comparisons(fh, bst_3)
total_1 = comparison_total(bst_1)
total_2 = comparison_total(bst_2)
"""
from BST_linked import BST
from functions import comparison_total , do_comparisons
from Letter import Letter
DATA1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
DATA2 = "MFTCJPWADHKNRUYBEIGLOQSVXZ"
DATA3 = "ETAOINSHRDLUCMPFYWGBVKJXZQ"
bst1 = BST()
bst2 = BST()
bst3 = BST()
for i in DATA1:
bst1.insert(Letter(i[0]))
for i in DATA2:
bst2.insert(Letter(i[0]))
for i in DATA3:
bst3.insert(Letter(i[0]))
f_variable = open("miserables.txt","r")
print("Comparing by order: ABCDEFGHIJKLMNOPQRSTUVWXYZ")
do_comparisons(f_variable, bst1)
