def test_huffnode_eq_repr(self):
huff1 = HuffmanNode('c', 5, None, None)
huff2 = HuffmanNode('d', 5, None, None)
self.assertNotEqual(huff1, huff2)
huff2.char = 'c'
self.assertEqual(huff1, huff2)
self.assertEqual(repr(huff1), "HuffmanNode(c, 5, None, None)")
def test_eq(self):
""" Tests whether two nodes are equal"""
node1 = HuffmanNode(4)
node2 = HuffmanNode(1)
node3 = HuffmanNode(4)
self.assertFalse(node1 == node2)
self.assertTrue(node1 == node3)
def test_repr(self):
""" Tests how the class represents itself"""
node1 = HuffmanNode(1)
node2 = HuffmanNode(4)
node3 = HuffmanNode(12, None, node1, node2)
expected = "Huffman Node(freq: 12, char: None, left: " \
"Huffman Node(freq: 1, char: None, left: None, right: " \
"None), right: Huffman Node(freq: 4, char: None, " \
"left: None, right: None))"
self.assertEqual(expected, repr(node3))
def _unpack_data(data):
"""
:param data: binary data as read from a file or pulled directly out
of a certificate extension. Data should be compressed
with huffman coding as described for v3 entitlement
certificates
:type data: binary string
:return: tuple: (list of HuffmanNode instances not yet in a
tree, binary string of leftover bits that were not
part of the zlib-compressed word list
:rtype: tuple(list, binary string)
"""
decompress = zlib.decompressobj()
decompressed_data = decompress.decompress(data)
# ordered list of words that will be composed into a huffman tree
words = decompressed_data.split('\0')
# enumerate() would be better here, but lacks a 'start' arg in 2.4
weighted_words = zip(itertools.count(1), words)
# huffman nodes, without having put them in a tree. These will all be
# leaves in the tree.
nodes = [
HuffmanNode(weight, value) for weight, value in weighted_words
]
return nodes, decompress.unused_data
def __init__(self, data):
"""
Uncompresses data into a tree that can be traversed for matching paths
:param data: binary data as read from a file or pulled directly out
of a certificate extension. Data should be compressed
with huffman coding as described for v3 entitlement
certificates
:type data: binary string
"""
word_leaves, unused_bits = self._unpack_data(data)
HuffmanNode.build_tree(word_leaves)
word_dict = dict((node.code, node.value) for node in word_leaves)
bitstream = GhettoBitStream(unused_bits)
path_leaves = self._generate_path_leaves(bitstream)
HuffmanNode.build_tree(path_leaves)
path_dict = dict((node.code, node) for node in path_leaves)
self.path_tree = self._generate_path_tree(path_dict, path_leaves, word_dict, bitstream)
def create_huff_tree(list_of_freqs):
"""returns the root node of a Huffman Tree
"""
huff_tree = []
for idx in range(len(list_of_freqs)):
if list_of_freqs[idx] != 0:
huff_tree.append(HuffmanNode(list_of_freqs[idx], chr(idx)))
huff_arr = MinPQ()
huff_arr.heapify(huff_tree)
while huff_arr.num_items > 1:
node1 = huff_arr.del_min()
node2 = huff_arr.del_min()
freq = node1.freq + node2.freq
char = min(node1.char, node2.char)
new_huff_node = HuffmanNode(freq, char)
new_huff_node.left = node1
new_huff_node.right = node2
huff_arr.insert(new_huff_node)
return huff_arr.min()
def __init__(self, data):
"""
Uncompresses data into a tree that can be traversed for matching paths
:param data: binary data as read from a file or pulled directly out
of a certificate extension. Data should be compressed
with huffman coding as described for v3 entitlement
certificates
:type data: binary string
"""
word_leaves, unused_bits = self._unpack_data(data)
HuffmanNode.build_tree(word_leaves)
word_dict = dict((node.code, node.value) for node in word_leaves)
bitstream = GhettoBitStream(unused_bits)
path_leaves = self._generate_path_leaves(bitstream)
HuffmanNode.build_tree(path_leaves)
path_dict = dict((node.code, node) for node in path_leaves)
self.path_tree = self._generate_path_tree(path_dict, path_leaves,
word_dict, bitstream)
def create_huff_tree(list_of_freqs):
"""Creates a huffman tree given a list of character frequencies.
Arguments:
list_of_freqs (list): List of character frequencies from cnt_freq()
Returns:
The root node of the huffman tree created from the list of frequencies
"""
pq_arr = []
for char, freq in enumerate(list_of_freqs):
if freq > 0:
pq_arr.append(HuffmanNode(chr(char), freq, None, None))
min_pq = MinPQ(pq_arr)
while min_pq.size() > 1:
left = min_pq.del_min()
right = min_pq.del_min()
min_char = min(left.char, right.char)
parent_node = HuffmanNode(min_char, left.freq + right.freq, left, right)
min_pq.insert(parent_node)
return min_pq.min()
def create_huff_tree(list_of_freqs):
"""creates the root node of a Huffman Tree using a list of freqencies
Args:
list_of_freqs (list): list of size 256 integers with the frequencies of characters in file
Returns:
HuffmanNode: the root of Huffman Tree
"""
heap_arr = []
for i in range(len(list_of_freqs)):
if list_of_freqs[i] != 0:
heap_arr.append(HuffmanNode(list_of_freqs[i], chr(i)))
min_heap = MinPQ(heap_arr)
while min_heap.num_items > 1:
huff_node1 = min_heap.del_min()
huff_node2 = min_heap.del_min()
new_huff_node = HuffmanNode(huff_node1.freq + huff_node2.freq,
min(huff_node1.char, huff_node2.char))
new_huff_node.left, new_huff_node.right = huff_node1, huff_node2
min_heap.insert(new_huff_node)
return min_heap.arr[0]
def create_huff_tree(list_of_freqs):
"""builds a huffman tree
Args:
list_of_freqs(list): list of frequencies from cnt_freq
Returns:
HuffmanNode: root node of the huffman tree
"""
min_huff = MinPQ() # min pq of huffman nodes
# for i in range(len(list_of_freqs)): # method 2: insert all huffman nodes
for i, item in enumerate(list_of_freqs):
if list_of_freqs[i] != 0:
min_huff.insert(HuffmanNode(list_of_freqs[i], chr(i)))
while min_huff.num_items != 1: # until a root node
low = min_huff.del_min() # HuffmanNode
low_2 = min_huff.del_min() # HuffmanNode
if ord(low.char) < ord(low_2.char):
char = low.char
else:
char = low_2.char
new_huff = HuffmanNode(low.freq + low_2.freq, char, low, low_2)
min_huff.insert(new_huff)
return min_huff.del_min() # pop out root node
def create_huff_tree(list_of_freqs):
""" Create a Huffman Tree from list of character frequencies
Args:
list_of_freqs(list): list with length of 256 characters
Returns:
MinPQ: the root node of the Min Priority Queue constructed from
the Huffman Nodes
"""
priority_queue_list = []
for each in range(len(list_of_freqs)):
if list_of_freqs[each] > 0:
char = chr(each)
freq = list_of_freqs[each]
node = HuffmanNode(freq, char)
priority_queue_list.append(node)
priority_queue = MinPQ(priority_queue_list)
if priority_queue.size() == 0:
return None
while priority_queue.size() > 1:
# Retrieves the two smallest occurring Nodes from the queue
node_1 = priority_queue.del_min()
node_2 = priority_queue.del_min()
# Determine the representation of the min chr representation
min_chr = min(node_1.char, node_2.char)
# Sum the different frequencies, create new Node, and add to queue
sum_freq = node_1.freq + node_2.freq
new_node = HuffmanNode(sum_freq, min_chr, node_1, node_2)
priority_queue.insert(new_node)
return priority_queue.del_min()
def _generate_path_leaves(cls, bitstream):
"""
Given the remaining bits after decompressing the word list, this
generates HummanNode objects to represent each node (besides root)
that will end up in the path tree.
:param bitstream: stream of bits remaining after decompressing the
word list
:type bitstream: rhsm.bitstream.GhettoBitStream
:return: list of HuffmanNode objects that can be used to
build a path tree
:rtype: list of HuffmanNode objects
"""
node_count = cls._get_node_count(bitstream)
nodes = []
# make leaves for a huffman tree and exclude the root node of the path
# tree, because we don't need a reference code for that.
for weight in range(1, node_count):
node = HuffmanNode(weight, {})
nodes.append(node)
return nodes
"""
list_of_freqs = [0] * 256
with open(filename) as file:
for line in file:
for char in line:
list_of_freqs[ord(char)] += 1
return list_of_freqs
def create_huff_tree(list_of_freqs):
"""returns the root node of a Huffman Tree
"""
tree = MinPQ()
<<<<<<< HEAD
for i in range(len(list_of_freqs)):
if list_of_freqs[i] != 0:
new = HuffmanNode(list_of_freqs[i], chr(i))
# tree.insert(new)
hufflist.append(new)
hufflist.sort()
# print(hufflist)
tree = MinPQ(hufflist)
# print('TREE AFTER INSERTION:\n', tree)
=======
for idx, freq in enumerate(list_of_freqs):
if freq != 0:
new = HuffmanNode(freq, chr(idx))
tree.insert(new)
>>>>>>> 1c1c70a6eb7b91e2d3714eb49057c9513665ab0d
while tree.num_items > 1:
left = tree.del_min()
right = tree.del_min()