def build_huffman_tree(self): vocab = self.get_vocab() vocab = {info[0]: info[1] for w, info in vocab.items()} self.huffman = HuffmanTree(vocab) self.huffman_left, self.huffman_right = self.huffman.generate_node_left_and_right_path( ) print("build_tree_complete")
def _get_min(symbol_list: List[Union[int, HuffmanTree]], freq_list: List[int]) \ -> Tuple[List[Union[int, HuffmanTree]], List[int]]: """ A helper function for build_huffman_tree that uses the <symbol_list> and <freq_list> to map the symbols and frequencies. """ output = [] total = 0 for i in range(2): # Pop smallest frequency and get its index small_freq = min(freq_list) index = freq_list.index(small_freq) # Add up the sum total += small_freq + i * 0 # Get the symbol for the freq. and pop the freq from the list symbol = symbol_list.pop(index) freq_list.pop(index) if isinstance(symbol, int): output.append(HuffmanTree(symbol)) elif isinstance(symbol, HuffmanTree): output.append(symbol) tree = HuffmanTree(None, output[0], output[1]) symbol_list.append(tree) freq_list.append(total) return symbol_list, freq_list
def __init__(self, file_name, args): self.args = args # 队列存储所有配对 self.word_pair_catch = deque() # 采样表 self.sample_table = [] # 去掉频率低于mini_count后所有的单词 self.sentence_length = 0 # 句子个数 self.sentence_count = 0 # 词 --> id self.word2id = {} # id --> 词 self.id2word = {} # 词频率 self.word_frequency = {} # 去重 去低频次 之后单词个数 self.word_count = 0 self.input_file = open(os.path.join(self.args.dir, file_name), encoding='utf-8').readlines() self.get_words() self.init_sample_table() if args.using_hs: tree = HuffmanTree(self.word_frequency) self.huffman_positive, self.huffman_negative = tree.get_huffman_code_and_path( ) print('Word Count: %d' % len(self.word2id)) print('Sentence Length: %d' % (self.sentence_length)) print('Sentence count: %d' % (self.sentence_count))
def make_tree(self, counter): """make_tree builds a HuffmanTree and creates a dictionary whose keys are symbols and whose values are the binary code for each symbol and then saves the tree as self.tree""" # sortedList = sorted(list, key = lambda HuffmanTree: HuffmanTree.freq) counterkeys = list(counter) myTrees = [] for i in counterkeys: myTrees += [HuffmanTree(symbol=i, freq=counter[i])] while (len(myTrees) > 1): lowest = self.lowest(myTrees) self.tree = lowest myTrees.remove(lowest) nextLow = self.lowest(myTrees) myTrees.remove(nextLow) self.tree = HuffmanTree(right=self.tree, left=nextLow, freq=self.tree.freq + nextLow.freq) myTrees += [self.tree] self.dict = dict(self.tree.get_codes()) dictionary = dict( list(map(lambda x: (x[1], x[0]), self.tree.get_codes()))) self.tree.read_dict(dictionary) return self.tree
def generate(sentence): with open('train.txt') as fin: train = fin.read() train += ' ' + preprocess(sentence) morse_codes = translateToMorseCode(train) huffman_tree = HuffmanTree() huffman_tree.train(morse_codes) print huffman_tree.translate(preprocess(sentence))
def generate_tree_postorder(node_lst: List[ReadNode], root_index: int) -> HuffmanTree: """ Return the Huffman tree corresponding to node_lst[root_index]. The function assumes that the list represents a tree in postorder. >>> lst = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), \ ReadNode(1, 0, 1, 0)] >>> generate_tree_postorder(lst, 2) HuffmanTree(None, HuffmanTree(None, HuffmanTree(5, None, None), \ HuffmanTree(7, None, None)), HuffmanTree(None, HuffmanTree(10, None, None),\ HuffmanTree(12, None, None))) >>> lst = [ReadNode(0, 104, 0, 101), ReadNode(0, 119, 0, 114), \ ReadNode(1, 0, 1, 1), ReadNode(0, 100, 0, 111), ReadNode(0, 108, 1, 3), \ ReadNode(1, 2, 1, 4)] >>> tree = generate_tree_postorder(lst, len(lst)-1) >>> print(tree) HuffmanTree(None, HuffmanTree(None, HuffmanTree(None, HuffmanTree(104, None, None), HuffmanTree(101, None, None)), \ HuffmanTree(None, HuffmanTree(119, None, None), \ HuffmanTree(114, None, None))), \ HuffmanTree(None, HuffmanTree(108, None, None), \ HuffmanTree(None, HuffmanTree(100, None, None), \ HuffmanTree(111, None, None)))) >>> number_nodes(tree) >>> t = bytes_to_nodes(tree_to_bytes(tree)) >>> t [ReadNode(0, 104, 0, 101), ReadNode(0, 119, 0, 114), ReadNode(1, 0, 1, 1),\ ReadNode(0, 100, 0, 111), ReadNode(0, 108, 1, 3), ReadNode(1, 2, 1, 4)] >>> lst = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), \ ReadNode(1, 0, 1, 0)] >>> tree = generate_tree_postorder(lst, 2) >>> number_nodes(tree) >>> t = bytes_to_nodes(tree_to_bytes(tree)) >>> t [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), ReadNode(1, 0, 1, 1)] """ tree = HuffmanTree(None) tree.right = _post_order_helper(node_lst, root_index, False) right_index = _find_height(tree.right) if right_index is None: right_index = 0 else: right_index = len(right_index) tree.left = _post_order_helper(node_lst, root_index, True, right_index) _post_order_set_none(tree) return tree
def build_huffman_tree(freq_dict: Dict[int, int]) -> HuffmanTree: """ Return the Huffman tree corresponding to the frequency dictionary <freq_dict>. Precondition: freq_dict is not empty. >>> freq = {2: 6, 3: 4} >>> t = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(3), HuffmanTree(2)) >>> t == result True >>> freq = {2: 6, 3: 4, 7: 5} >>> t = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(2), \ HuffmanTree(None, HuffmanTree(3), HuffmanTree(7))) >>> t == result True >>> import random >>> symbol = random.randint(0,255) >>> freq = {symbol: 6} >>> t = build_huffman_tree(freq) >>> any_valid_byte_other_than_symbol = (symbol + 1) % 256 >>> dummy_tree = HuffmanTree(any_valid_byte_other_than_symbol) >>> result = HuffmanTree(None, HuffmanTree(symbol), dummy_tree) >>> t.left == result.left or t.right == result.left True >>> freq = {2: 6, 3: 4, 7: 5, 8: 4} >>> tree = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(None, \ HuffmanTree(3, None, None), HuffmanTree(8, None, None)), \ HuffmanTree(None, HuffmanTree(7, None, None), HuffmanTree(2, None, None))) >>> tree == result True >>> freq = {3: 1} >>> tree = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(3, None, None), HuffmanTree(2, \ None, None)) >>> tree == result True """ # Empty dictionary if freq_dict == {}: return HuffmanTree(None) # Only one item in freq_dict elif len(freq_dict) == 1: return HuffmanTree(None, HuffmanTree(list(freq_dict)[0]), HuffmanTree(2)) else: symbol_list = list(freq_dict) freq_list = list(freq_dict.values()) while len(symbol_list) > 1: symbol_list, freq_list = _get_min(symbol_list, freq_list) return symbol_list[0]
def generate_tree_general(node_lst: List[ReadNode], root_index: int) -> HuffmanTree: """ Return the Huffman tree corresponding to node_lst[root_index]. The function assumes nothing about the order of the tree nodes in the list. >>> lst = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), \ ReadNode(1, 1, 1, 0)] >>> generate_tree_general(lst, 2) HuffmanTree(None, HuffmanTree(None, HuffmanTree(10, None, None), \ HuffmanTree(12, None, None)), \ HuffmanTree(None, HuffmanTree(5, None, None), HuffmanTree(7, None, None))) >>> leftleft = HuffmanTree(None, HuffmanTree(20), HuffmanTree(71)) >>> left = HuffmanTree(None, HuffmanTree(3), leftleft) >>> right = HuffmanTree(None, HuffmanTree(9), HuffmanTree(10)) >>> tree = HuffmanTree(None, left, right) >>> generate_tree_general([ReadNode(1, 2, 1, 3), ReadNode(0, 4, 0, 12), ReadNode(1, 1, 0, 2), ReadNode(0, 9, 0, 10)], 0) HuffmanTree(None, HuffmanTree(None, HuffmanTree(None, \ HuffmanTree(4, None, None), HuffmanTree(12, None, None)), \ HuffmanTree(2, None, None)), HuffmanTree(None, HuffmanTree(9, None, None), \ HuffmanTree(10, None, None))) """ curr_node = node_lst[root_index] tree = HuffmanTree() if curr_node.l_type == 0: tree.left = HuffmanTree(curr_node.l_data) else: treex = generate_tree_general(node_lst, curr_node.l_data) tree.left = treex if curr_node.r_type == 0: tree.right = HuffmanTree(curr_node.r_data) else: treey = generate_tree_general(node_lst, curr_node.r_data) tree.right = treey return tree
def generate_tree_general(node_lst: List[ReadNode], root_index: int) -> HuffmanTree: """ Return the Huffman tree corresponding to node_lst[root_index]. The function assumes nothing about the order of the tree nodes in the list. >>> lst = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), \ ReadNode(1, 1, 1, 0)] >>> generate_tree_general(lst, 2) HuffmanTree(None, HuffmanTree(None, HuffmanTree(10, None, None), \ HuffmanTree(12, None, None)), \ HuffmanTree(None, HuffmanTree(5, None, None), HuffmanTree(7, None, None))) """ # 0 is leaf, 1 is not a leaf root = node_lst[root_index] tree = HuffmanTree(None, None, None) if root.l_type == 1: a = node_lst[root.l_data] tree.left = __generate_tree_gen_help(node_lst, a) else: tree.left = HuffmanTree(root.l_data, None, None) if root.r_type == 1: a = node_lst[root.r_data] tree.right = __generate_tree_gen_help(node_lst, a) else: tree.right = HuffmanTree(root.r_data, None, None) return tree
def _number_nodes_helper(tree: HuffmanTree, number: int = 0) -> int: """ A helper function that uses a <tree> to <number> the internal nodes. """ if tree.is_leaf(): return number - 1 else: number = _number_nodes_helper(tree.left, number) + 1 number = _number_nodes_helper(tree.right, number) + 1 tree.number = number return number
def __init__(self, file_name, min_count): self.get_words(file_name, min_count) print(" ") self.cbow_count = [] self.word_pair_catch = deque() self.cbow_word_pair_catch = deque() self.init_sample_table() tree = HuffmanTree(self.word_frequency) print("tree ", tree) self.huffman_positive, self.huffman_negative = tree.get_huffman_code_and_path( ) print('Word Count: %d' % len(self.word2id)) print('Sentence Length: %d' % (self.sentence_length))
def __init__(self, input_file, min_count): self.input_file = input_file self.sentence_sum_length = 0 # 用于统计句子中出现单词的总数量 self.sentence_count = 0 # 用于统计随机游走数量 self.word_count = 0 self.word2id = dict() self.id2word = dict() self.word_frequency = dict() # 词频:用于统计随机游走学列中单词出现的次数 self.word_pair_catch = deque() # 是什么 self.get_words(min_count) tree = HuffmanTree(self.word_frequency) self.huffman_positive, self.huffman_negative = tree.divide_pos_and_neg( )
def test_create_leafs(self): leafs = HuffmanTree.create_leafs("test") expect = [Leaf("t", 0.5), Leaf("e", 0.25), Leaf("s", 0.25)] self.do_lists_of_leafs_equal(list(leafs), expect) leafs = HuffmanTree.create_leafs("aaaaaaaAAAAbbbbb eee") expect = [ Leaf("a", 0.35), Leaf("A", 0.2), Leaf("b", 0.25), Leaf(" ", 0.05), Leaf("e", 0.15) ] self.do_lists_of_leafs_equal(list(leafs), expect)
def test_compute_code(self): tree = InternalNode(1, Leaf("a", 0.5), Leaf("b", 0.5)) code = HuffmanTree.compute_code(tree) self.assertEqual(code, {'a': '0', 'b': '1'}) tree = InternalNode( 1, Leaf("a", 0.5), InternalNode(0.5, Leaf("b", 0.25), Leaf("c", 0.25))) code = HuffmanTree.compute_code(tree) self.assertEqual(code, {'a': '0', 'b': '10', 'c': '11'}) tree = InternalNode( 1, Leaf("a", 0.5), InternalNode(0.5, Leaf("b", 0.25), InternalNode(0.25, Leaf("c", 0.1), Leaf("d", 0.15)))) code = HuffmanTree.compute_code(tree) self.assertEqual(code, {'a': '0', 'b': '10', 'c': '110', 'd': '111'})
def build_huffman_tree(freq_dict: Dict[int, int]) -> HuffmanTree: """ Return the Huffman tree corresponding to the frequency dictionary <freq_dict>. Precondition: freq_dict is not empty. >>> freq = {2: 6, 3: 4} >>> t = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(3), HuffmanTree(2)) >>> t == result True >>> freq = {2: 6, 3: 4, 7: 5} >>> t = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(2), \ HuffmanTree(None, HuffmanTree(3), HuffmanTree(7))) >>> t == result True >>> import random >>> symbol = random.randint(0,255) >>> freq = {symbol: 6} >>> t = build_huffman_tree(freq) >>> any_valid_byte_other_than_symbol = (symbol + 1) % 256 >>> dummy_tree = HuffmanTree(any_valid_byte_other_than_symbol) >>> result = HuffmanTree(None, HuffmanTree(symbol), dummy_tree) >>> t.left == result.left or t.right == result.right True """ if len(freq_dict) == 1: index = 0 for el in freq_dict: index = el return HuffmanTree(None, HuffmanTree(index), None) freq_dict2 = create_leafs(freq_dict) while len(freq_dict2) != 1: i, j = find_smallest_dict(freq_dict2) smallest = freq_dict2[i][1] second_smallest = freq_dict2[j][1] temp = HuffmanTree(None, smallest, second_smallest) combined_freq = freq_dict2[i][0] + freq_dict2[j][0] sym = str(i) + str(j) freq_dict2[sym] = [combined_freq, temp] freq_dict2.pop(i) freq_dict2.pop(j) index = 0 for el in freq_dict2: index = el return freq_dict2[index][1]
def get_codes(tree: HuffmanTree) -> Dict[int, str]: """ Return a dictionary which maps symbols from the Huffman tree <tree> to codes. >>> tree = HuffmanTree(None, HuffmanTree(3), HuffmanTree(2)) >>> d = get_codes(tree) >>> d == {3: "0", 2: "1"} True >>> tree = HuffmanTree(None, None, None) >>> d = get_codes(tree) >>> d == {} True >>> left = HuffmanTree(None, HuffmanTree(3), HuffmanTree(2)) >>> right = HuffmanTree(9) >>> tree = HuffmanTree(None, left, right) >>> d_test = get_codes(tree) >>> d_test == {3: "00", 2: "01", 9: "1"} True >>> left_ext = HuffmanTree(None, HuffmanTree(2), HuffmanTree(3)) >>> left = HuffmanTree(None, HuffmanTree(1), left_ext) >>> right = HuffmanTree(None, HuffmanTree(9), HuffmanTree(10)) >>> tree = HuffmanTree(None, left, right) >>> d = get_codes(tree) >>> d == {1: '00', 2: '010', 3: '011', 9: '10', 10: '11'} True >>> tree = HuffmanTree(None, HuffmanTree(3), HuffmanTree(2)) >>> d_text = get_codes(tree) >>> d_text {3: '0', 2: '1'} """ # Edge Case if tree is None or (tree.symbol is None and tree.is_leaf()): return {} else: return _get_codes_helper(tree, "")
def number_nodes(tree: HuffmanTree) -> None: """ Number internal nodes in <tree> according to postorder traversal. The numbering starts at 0. >>> leftleft = HuffmanTree(None, HuffmanTree(4), HuffmanTree(12)) >>> left = HuffmanTree(None, leftleft, HuffmanTree(2)) >>> right = HuffmanTree(None, HuffmanTree(9), HuffmanTree(10)) >>> tree = HuffmanTree(None, left, right) >>> number_nodes(tree) >>> tree.left.left.number 0 >>> tree.left.number 1 >>> tree.right.number 2 >>> tree.number 3 """ curr_number = 0 list_of_nodes = [] dict_of_nodes = find_internal_nodes(tree, 0) for el in dict_of_nodes: list_of_nodes.append(el) list_of_nodes.reverse() for el in list_of_nodes: for tree in dict_of_nodes[el]: tree.number = curr_number curr_number += 1
def _traverse_post_order(tree: HuffmanTree, byte_list: List[int] = None) \ -> List: """ Traverses a <tree> in post order and appends 1 if it is a leaf, 0 if it is a node, and other specifications. """ if not tree.is_leaf(): if byte_list is None: byte_list = [] byte_list = _traverse_post_order(tree.left, byte_list) byte_list = _traverse_post_order(tree.right, byte_list) if not tree.left.is_leaf(): byte_list.append(1) byte_list.append(tree.left.number) if tree.left.is_leaf(): byte_list.append(0) byte_list.append(tree.left.symbol) if not tree.right.is_leaf(): byte_list.append(1) byte_list.append(tree.right.number) if tree.right.is_leaf(): byte_list.append(0) byte_list.append(tree.right.symbol) return byte_list
def tree_to_bytes(tree: HuffmanTree) -> bytes: """ Return a bytes representation of the Huffman tree <tree>. The representation should be based on the postorder traversal of the tree's internal nodes, starting from 0. Precondition: <tree> has its nodes numbered. >>> tree = HuffmanTree(None, HuffmanTree(3, None, None), \ HuffmanTree(2, None, None)) >>> number_nodes(tree) >>> list(tree_to_bytes(tree)) [0, 3, 0, 2] >>> left = HuffmanTree(None, HuffmanTree(3, None, None), \ HuffmanTree(2, None, None)) >>> right = HuffmanTree(5) >>> tree = HuffmanTree(None, left, right) >>> number_nodes(tree) >>> list(tree_to_bytes(tree)) [0, 3, 0, 2, 1, 0, 0, 5] >>> tree = build_huffman_tree(build_frequency_dict(b"helloworld")) >>> number_nodes(tree) >>> list(tree_to_bytes(tree)) #doctest: +NORMALIZE_WHITESPACE [0, 104, 0, 101, 0, 119, 0, 114, 1, 0, 1, 1, 0, 100, 0, 111, 0, 108,\ 1, 3, 1, 2, 1, 4] >>> tree = HuffmanTree(None, HuffmanTree(None, HuffmanTree(10, None, None),\ HuffmanTree(12, None, None)), \ HuffmanTree(None, HuffmanTree(5, None, None), HuffmanTree(7, None, None))) >>> number_nodes(tree) >>> list(tree_to_bytes(tree)) [0, 10, 0, 12, 0, 5, 0, 7, 1, 0, 1, 1] """ if tree.is_leaf() and tree.symbol is None: return bytes([]) else: return bytes(_traverse_post_order(tree))
def __huffman_helper(real: HuffmanTree) -> None: """Helper function for build_huffman trees where it basically goes through the tree turning the internal nodes symbols to None""" if not real.is_leaf and real is not None: real.symbol = None __huffman_helper(real.left) __huffman_helper(real.right)
def __preorder_pls(tree: HuffmanTree, freq_dict: Dict[int, int], ff: Dict[int, int]) -> None: if tree.is_leaf and tree.symbol is not None: tree.symbol = freq_dict[max(freq_dict.keys())] freq_dict.pop(max(freq_dict.keys())) else: __preorder_pls(tree.left, freq_dict, ff) __preorder_pls(tree.right, freq_dict, ff)
class HuffmanDecoder(object): def decode(self, filename): self.filename = filename self.read_key_file() self.read_message_file() self.write_to_file() def read_key_file(self): """read_key_file reads in lines from the filename.txt.HUFFMAN.KEY""" fp = open(self.filename + ".KEY") numOfSymbols = int(fp.readline()) self.fileLength = int(fp.readline()) self.dictionary = {} for i in range(numOfSymbols): sym = fp.read(1) code = fp.readline().strip() self.dictionary[code] = sym fp.close() def read_message_file(self): """read_message_file uncompresseses a binary (byte) file and save the resulting text as self.text using the HuffmanTree class's find_char method""" f = open(self.filename, "rb") readBytes = f.read() f.close() readBytes = list(readBytes) stringOfBits = "" for i in range(len(readBytes)): stringOfBits += binary.EightBitNumToBinary(readBytes[i]) self.tree = HuffmanTree() self.tree.read_dict(self.dictionary) toPrint = "" for i in range(self.fileLength): toPrint += self.tree.find_char(stringOfBits)[0] stringOfBits = stringOfBits[ self.tree.find_char(stringOfBits)[1]: ] self.text = toPrint def write_to_file(self): """write_to_file writes the text from self.text to a new file called self.filename.HUFFMAN.DECODED""" f = open(self.filename + ".DECODED", "w") f.write(self.text) f.close()
def build_huffman_tree(freq_dict: Dict[int, int]) -> HuffmanTree: # FIX THIS """ Return the Huffman tree corresponding to the frequency dictionary <freq_dict>. Precondition: freq_dict is not empty. >>> freq = {2: 6, 3: 4} >>> t = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(3), HuffmanTree(2)) >>> t == result True >>> freq = {2: 6, 3: 4, 7: 5} >>> t = build_huffman_tree(freq) >>> result = HuffmanTree(None, HuffmanTree(2), \ HuffmanTree(None, HuffmanTree(3), HuffmanTree(7))) >>> t == result True >>> import random >>> symbol = random.randint(0,255) >>> freq = {symbol: 6} >>> t = build_huffman_tree(freq) >>> any_valid_byte_other_than_symbol = (symbol + 1) % 256 >>> dummy_tree = HuffmanTree(any_valid_byte_other_than_symbol) >>> result = HuffmanTree(None, HuffmanTree(symbol), dummy_tree) >>> t.left == result.left or t.right == result.left True """ if len(freq_dict) == 1: a = list(freq_dict.keys()) b = (a[0] + 1) % 256 return HuffmanTree(None, HuffmanTree(a[0]), HuffmanTree(b)) lst = [(freq_dict[j], j) for j in freq_dict] lst.sort() lst2 = [] for i in lst: lst2.append((i[0], HuffmanTree(i[1]))) while len(lst2) > 1: za = lst2.pop(0) warudo = lst2.pop(0) a = HuffmanTree(None, za[1], warudo[1]) lst2.append((za[0] + warudo[0], a)) lst2.sort() real = lst2[0][1] __huffman_helper(real) return real
def _clean_huff_tree(tree: HuffmanTree): """ convert all HuffmanTree.number to None after using it to keep list sorted """ if tree: _clean_huff_tree(tree.left) _clean_huff_tree(tree.right) tree.number = None
def huffman_encoding(text): if not text: raise ValueError("Text is empty. Abort encoding.") tree = HuffmanTree() tree.grow(text).encode() char_code = tree.get_mapping() res = "" for char in text: try: code = char_code[char] except: raise KeyError( f"{char} does not exist in the mapping. Abort encoding.") res += code return res, tree
def test_decode(self): self.assertEqual( HuffmanTree.decode("010110", { "t": "0", "e": "10", "s": "11" }), "test") self.assertEqual( HuffmanTree.decode("00101111100", { "t": "00", "e": "1011", "s": "111" }), "test") self.assertRaises(Exception, HuffmanTree.decode, "0101101", { "t": "0", "e": "10", "s": "11" })
def _recursive_numbering(tree: HuffmanTree, cur_num: list): """ Algorithm that recursively builds and mutates the huff_map """ if tree.is_leaf(): # dont number leaves return elif not tree: # blank tree, graceful termiantion return else: _recursive_numbering(tree.left, cur_num) # then right _recursive_numbering(tree.right, cur_num) # finally root tree.number = cur_num[0] cur_num[0] += 1
def _swap(tree: HuffmanTree, dic: Dict) -> None: """ Swaps the values. """ if tree.symbol: if tree.symbol in dic: tree.symbol = dic[tree.symbol] else: _swap(tree.left, dic) _swap(tree.right, dic)
def read_message_file(self): """read_message_file uncompresseses a binary (byte) file and save the resulting text as self.text using the HuffmanTree class's find_char method""" f = open(self.filename, "rb") readBytes = f.read() f.close() readBytes = list(readBytes) stringOfBits = "" for i in range(len(readBytes)): stringOfBits += binary.EightBitNumToBinary(readBytes[i]) self.tree = HuffmanTree() self.tree.read_dict(self.dictionary) toPrint = "" for i in range(self.fileLength): toPrint += self.tree.find_char(stringOfBits)[0] stringOfBits = stringOfBits[ self.tree.find_char(stringOfBits)[1]: ] self.text = toPrint
def __generate_tree_gen_help(node_lst: list, a: ReadNode) -> HuffmanTree: """Helper for generate tree general""" buff = HuffmanTree(None, None, None) if a.l_type == 0: buff.left = HuffmanTree(a.l_data, None, None) else: b = node_lst[a.l_data] buff.left = __generate_tree_gen_help(node_lst, b) if a.r_type == 0: buff.right = HuffmanTree(a.r_data, None, None) else: b = node_lst[a.r_data] buff.right = __generate_tree_gen_help(node_lst, b) return buff
def generate_tree_general(node_lst: List[ReadNode], root_index: int) -> HuffmanTree: """ Return the Huffman tree corresponding to node_lst[root_index]. The function assumes nothing about the order of the tree nodes in the list. >>> lst = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), \ ReadNode(1, 1, 1, 0)] >>> generate_tree_general(lst, 2) HuffmanTree(None, HuffmanTree(None, HuffmanTree(10, None, None), \ HuffmanTree(12, None, None)), \ HuffmanTree(None, HuffmanTree(5, None, None), HuffmanTree(7, None, None))) """ # TODO: Implement this function if len(node_lst) == 0: return HuffmanTree(None) for node in node_lst: if node.l_type == 0: # if left side is a leaf pass else: pass