def build_codes(tree, ls=al.ArrayList([None] * 250), acc=""):
if type(tree) == Leaf:
al.set(ls, tree.char, acc)
else:
build_codes(tree.left, ls, acc + "0")
build_codes(tree.right, ls, acc + "1")
return ls
def test_build_tree(self):
self.assertEqual(build_tree(self.huff_list), self.huff_tree)
self.assertEqual(
build_tree(al.set(al.set(al.ArrayList([None] * 250), 32, 3), 98,
3)), self.tree0)
self.assertEqual(
build_tree(freq_counter("first.txt")),
Node(97, 6, Leaf(97, 3), Node(98, 3, Leaf(99, 1), Leaf(98, 2))))
def build_codes(tree,alist,accl=""):
if(tree==None):
return tree
if(type(tree)==Node):
build_codes(tree.left,alist,accl+"0")
build_codes(tree.right,alist,accl+"1")
else:
array_list.set(alist,tree.char,accl)
def chr_code(nd, x):
new = array_list.empty_list()
if type(nd) == Leaf:
for i in range(x.capacity):
if array_list.get(x, i) != None:
new = array_list.set(new, i, '0')
return new
else:
for i in range(x.capacity):
if array_list.get(x, i) != None:
new = array_list.set(new, i, indv_code(nd, chr(i)))
return new
def huffman_decode(inf, outf):
hb_reader = HuffmanBitsReader(inf)
outFile = open(outf, 'w')
new = array_list.empty_list()
char_num = hb_reader.read_byte()
if char_num == 0:
hb_reader.close()
outFile.close()
return None
for i in range(char_num):
index = hb_reader.read_byte()
occ = hb_reader.read_int()
new = array_list.set(new, index, occ)
x = build_leaf(new, comes_before)
lst = build_nodes(x)
string = ''
if type(lst) == Node:
temp = lst
for i in range(check_size(new, chr_code(lst, new))):
bit = hb_reader.read_bit()
if bit == True:
temp = temp.right
else:
temp = temp.left
if type(temp) == Leaf:
string += temp.character
temp = lst
if type(lst) == Leaf:
for i in range(lst.occurrence):
string += lst.character
outFile.write(string)
hb_reader.close()
outFile.close()
return None
def header_reader(bitreader):
alist= array_list.List([0]*256,256,256)
count=bitreader.read_byte()
for i in range(count):
char=bitreader.read_byte()
num=bitreader.read_int()
alist=array_list.set(alist,char,num)
return alist
def count(inf):
inFile = open(inf, 'r')
if inFile.readline() == '':
inFile.close()
return array_list.empty_list()
else:
inFile.close()
inFile = open(inf, 'r')
new = array_list.empty_list()
for temp in inFile:
for char in range(len(temp)):
index = ord(temp[char])
val = array_list.get(new, index)
if val == None:
new = array_list.set(new, index, 1)
else:
new = array_list.set(new, index, val + 1)
inFile.close()
return new
def count_occurances(path):
file=open_file(path)
if(file==None):
return None
else:
huffcount=array_list.List([0]*256,256,256)
for line in file:
for ch in line:
val=ord(ch)
huffcount=array_list.set(huffcount, val , array_list.get(huffcount,val)+1)
file.close()
return huffcount
def test_length_of_decode(self):
hb_reader = HuffmanBitsReader('test_encoded.bin')
new = array_list.empty_list()
char_num = hb_reader.read_byte()
for i in range(char_num):
index = hb_reader.read_byte()
occ = hb_reader.read_int()
new = array_list.set(new, index, occ)
x = build_leaf(new, comes_before)
lst = build_nodes(x)
hb_reader.close()
self.assertEqual(check_size(new, chr_code(lst, new)), 29)
def test_freq_counter(self):
self.assertRaises(FileNotFoundError, freq_counter, "fake_file.txt")
al_first = al.ArrayList([None] * 250)
al.set(al_first, 97, 3)
al.set(al_first, 98, 2)
al.set(al_first, 99, 1)
self.assertEqual(freq_counter("first.txt"), al_first)
def huffman_decode(input, output):
read_from = HuffmanBitsReader(input)
write_to = open(output, 'w')
number_of_codes = read_from.read_byte()
times = 0
occur_list = array_list.empty_list()
occur_list = ([None] * 256)
total_characters = 0
while times < number_of_codes:
char = read_from.read_byte()
freq = read_from.read_int()
total_characters += freq
times += 1
occur_list = array_list.set(occur_list, char, freq)
if total_characters == 0:
write_to.write('')
write_to.close()
read_from.close()
return
sorted_list = make_sorted_list(occur_list)
pairtree = join_leaves(sorted_list)
tree = pairtree.first
temp_tree = tree
#print(total_characters)
#read bit by bit and get the code
bit = True
code = ''
chars = 0
#write_to.write('\n')
while bit == True or bit == False and chars < total_characters:
bit = read_from.read_bit()
if type(tree) != type(Leaf(1, 2)):
if bit == True:
tree = tree.right
code += '1'
elif bit == False:
tree = tree.left
code += '0'
if type(tree) == type(Leaf('a', 2)):
char = chr(tree.character)
write_to.write(char)
tree = temp_tree
chars += 1
#print(code)
#write_to.write('\n')
write_to.close()
read_from.close()
def test_build_codes(self):
self.assertEqual(
build_codes(self.huff_tree),
al.set(
al.set(
al.set(
al.set(al.set(al.ArrayList([None] * 250), 32, "00"),
98, "01"), 100, "100"), 99, "101"), 97, "11"))
self.assertEqual(
build_codes(build_tree(self.huff_list)),
al.set(
al.set(
al.set(
al.set(al.set(al.ArrayList([None] * 250), 32, "00"),
98, "01"), 100, "100"), 99, "101"), 97, "11"))
self.assertEqual(
build_codes(build_tree(freq_counter("huff_ex.txt"))),
al.set(
al.set(
al.set(
al.set(al.set(al.ArrayList([None] * 250), 32, "00"),
98, "01"), 100, "100"), 99, "101"), 97, "11"))
class TestList(unittest.TestCase):
huff_list = al.set(
al.set(
al.set(al.set(al.set(al.ArrayList([None] * 250), 97, 4), 98, 3),
99, 2), 100, 1), 32, 3)
huff_tree = Node(
32, 13, Node(32, 6, Leaf(32, 3), Leaf(98, 3)),
Node(97, 7, Node(99, 3, Leaf(100, 1), Leaf(99, 2)), Leaf(97, 4)))
tree0 = Node(32, 6, Leaf(32, 3), Leaf(98, 3))
tree1 = Node(97, 7, Node(99, 3, Leaf(100, 1), Leaf(99, 2)), Leaf(97, 4))
print(tree0)
def test_freq_counter(self):
self.assertRaises(FileNotFoundError, freq_counter, "fake_file.txt")
al_first = al.ArrayList([None] * 250)
al.set(al_first, 97, 3)
al.set(al_first, 98, 2)
al.set(al_first, 99, 1)
self.assertEqual(freq_counter("first.txt"), al_first)
def test_tree_traversal(self):
self.assertEqual(tree_traversal(self.tree0), " b")
self.assertEqual(tree_traversal(self.tree1), "dca")
self.assertEqual(tree_traversal(self.huff_tree), " bdca")
def test_comes_before(self):
self.assertEqual(comes_before(self.tree0, self.tree1), True)
self.assertEqual(comes_before(self.huff_tree, self.tree0), False)
self.assertEqual(comes_before(Leaf(32, 3), Leaf(98, 3)), True)
def test_build_sorted_leaves(self):
self.assertEqual(
build_sorted_leaves(self.huff_list),
ll.Pair(
Leaf(100, 1),
ll.Pair(
Leaf(99, 2),
ll.Pair(Leaf(32, 3),
ll.Pair(Leaf(98, 3), ll.Pair(Leaf(97, 4)))))))
def test_build_tree(self):
self.assertEqual(build_tree(self.huff_list), self.huff_tree)
self.assertEqual(
build_tree(al.set(al.set(al.ArrayList([None] * 250), 32, 3), 98,
3)), self.tree0)
self.assertEqual(
build_tree(freq_counter("first.txt")),
Node(97, 6, Leaf(97, 3), Node(98, 3, Leaf(99, 1), Leaf(98, 2))))
def test_build_codes(self):
self.assertEqual(
build_codes(self.huff_tree),
al.set(
al.set(
al.set(
al.set(al.set(al.ArrayList([None] * 250), 32, "00"),
98, "01"), 100, "100"), 99, "101"), 97, "11"))
self.assertEqual(
build_codes(build_tree(self.huff_list)),
al.set(
al.set(
al.set(
al.set(al.set(al.ArrayList([None] * 250), 32, "00"),
98, "01"), 100, "100"), 99, "101"), 97, "11"))
self.assertEqual(
build_codes(build_tree(freq_counter("huff_ex.txt"))),
al.set(
al.set(
al.set(
al.set(al.set(al.ArrayList([None] * 250), 32, "00"),
98, "01"), 100, "100"), 99, "101"), 97, "11"))
