def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' bitreader = bitio.BitReader(compressed) bitwriter = bitio.BitWriter(uncompressed) # read the tree from the compressed stream tree = read_tree(bitreader) # keep decoding bytes and writing to the uncompressed stream until the # EOF symbol is reached while True: decoded = decode_byte(tree, bitreader) if decoded == None: break bitwriter.writebits(decoded, 8)
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' write_tree(tree, compressed) # instantiate classes bitwriter = bitio.BitWriter(compressed) bitreader = bitio.BitReader(uncompressed) # create table with paths to bytes table = huffman.make_encoding_table(tree) end_of_file = False while not end_of_file: try: # read in byte compress = bitreader.readbits(8) # write byte in compressed form for el in (table[compress]): bitwriter.writebit(el) except EOFError: # reached end of file bitwriter.flush() end_of_file = True
def compress(tree, uncompressed, compressed): write_tree(tree, compressed) encoding_table = huffman.make_encoding_table(tree) values_table = list(encoding_table.values()) keys_table = list(encoding_table.keys()) mybytereader = bitio.BitReader(uncompressed) endoffile = False list1 = [] while not endoffile: try: mybyte = mybytereader.readbits(8) list1.append(mybyte) except EOFError: endoffile = True mybitwriter = bitio.BitWriter(compressed) for i in list1: if i in encoding_table.keys(): code = encoding_table[i] for h in code: mybitwriter.writebit(h) mybitwriter.writebit(None) mybitwriter.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' # read the tree from the compressed file tree = read_tree(compressed) # initialize bit reading readin = bitio.BitReader(compressed) not_end_file = True # initialize new file for bit writing writeout = bitio.BitWriter(uncompressed) while not_end_file: try: # recursively decode one byte byte = decode_byte(tree, readin) if byte != None: writeout.writebits(byte, 8) except EOFError: not_end_file = False # push changes to file writeout.flush() writeout.flush()
def decompress(compressed, uncompressed): # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # First, read a Huffman tree from the 'tree_stream' using your # read_tree function. Then use that tree to decode the rest of the # stream and write the resulting symbols to the 'uncompressed' # stream. # Args: # compressed: A file stream from which compressed input is read. # uncompressed: A writable file stream to which the uncompressed # output is written. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # unpickling the tree from the compressed file stream unpkltree = read_tree(compressed) # creating BitReader and BitWriter objects bitread = bitio.BitReader(compressed) bitwriter = bitio.BitWriter(uncompressed) while True: try: nextbyte = decode_byte(unpkltree, bitread) # use bitwriter to write indiviual bits to a file bitwriter.writebits(nextbyte, 8) except: break # flushing the bit writer object bitwriter.flush() pass
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' decompTree = read_tree(compressed) # read whole tree binary = bitio.BitReader(compressed) # convert compressed to binary writing = bitio.BitWriter(uncompressed) # writing to huff tree to var end = False place = 0 while end == False: try: place = decode_byte(decompTree, binary) # compare whole tree with binary writing.writebits(place, 8) except: end = True writing.flush() pass
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' #set up reader and writer reader = bitio.BitReader(compressed) writer = bitio.BitWriter(uncompressed) #read in and construct tree tree = read_tree(reader) while (True): byte = decode_byte(tree, reader) #if the byte is the eof char, break you are done if byte == None: break else: #write bits to uncompressed file writer.writebits(byte, 8)
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' #let compressed be an instance of bitio.BitReader reading = bitio.BitReader(compressed) #use read_tree to get the huffman tree tree = read_tree(reading) #let uncompressed be an instance of bitio.BitWriter Target = bitio.BitWriter(uncompressed) while True: #get the value of leaf val = decode_byte(tree, reading) #if EOF just break if val is None: break #write the value of leaf to uncompressed file Target.writebits(val,8) Target.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' # load the tree tree = read_tree(compressed) # Instantiate the Bit Reader and Bit Writer objects read_bit = bitio.BitReader(compressed) write_val = bitio.BitWriter(uncompressed) # Continously decode the bytes from the compressed file until EOF is # reached try: while True: val = decode_byte(tree, read_bit) write_val.writebits(val, 8) except: pass # EOF # flush the bitwriter write_val.flush() return
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' tree = read_tree(compressed) encoded = bitio.BitReader(compressed) decoded = bitio.BitWriter(uncompressed) end_of_file = False try: while not end_of_file: byte = decode_byte(tree, encoded) if byte is None: end_of_file = True else: decoded.writebits(byte, 8) except EOFError: end_of_file = True
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' write_tree(tree, compressed) decoded = bitio.BitReader(uncompressed) encoded = bitio.BitWriter(compressed) table = huffman.make_encoding_table(tree) end_of_file = False try: while not end_of_file: byte = decoded.readbits(8) for x in table[byte]: encoded.writebit(x) except EOFError: for x in table[None]: encoded.writebit(x) encoded.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' flag = 1 # We get the bits from the compressed stream and use it to obtain our tree unpickled = read_tree(compressed) # Bit Reader object is created in_stream = bitio.BitReader(compressed) # Bit Writer object is created out_stream = bitio.BitWriter(uncompressed) while flag == 1: # Coded bits will be decoded until we reach the end and None will be returned decoded = decode_byte(unpickled, in_stream) if decoded == None: flag = 0 # Keep writing the bits until we reach the end of the file elif decoded != None: out_stream.writebits(decoded, 8) out_stream.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' bitreader = bitio.BitReader(compressed) bitwriter = bitio.BitWriter(uncompressed) # read Huffman tree from beginning of file tree = read_tree(bitreader) # while compressed stream has data while True: b = decode_byte(tree, bitreader) # if we reach the end if b == None: break else: # write decoded bytes bitwriter.writebits(b, 8)
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' # instances of the BitReader and BitWriter reader = bitio.BitReader(compressed) writer = bitio.BitWriter(uncompressed) # first read the huffman tree off the compressed file huffman_tree = read_tree(reader) # continue to read the bytes encoded using tree while True: # decode the next byte byte_read = decode_byte(huffman_tree, reader) # stop when end-of-message is read if byte_read == None: break # write the byte to the uncompressed file writer.writebits(byte_read, 8)
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' # no try statement given, becuase if file exists, and try: write_tree(tree, compressed) except: print("File does not contain any bits to compress") return encoding_table = huffman.make_encoding_table(tree) # open using bitio bitread = bitio.BitReader(uncompressed) bitwrite = bitio.BitWriter(compressed) # assume EOF is not reached eof = False # read till EOF is reached while not eof: try: # read 8 bits to byte byte = bitread.readbits(8) # encode using encoding_table code = encoding_table[byte] # write code bitwise for bit in code: bitwrite.writebit(bit) # this is a crucial step to ensure loop stops # and compressed files are marked with None to indicate EOF except EOFError: # stop loop eof = True # manually write None to indicate EOF to decompressor code = encoding_table[None] for bit in code: bitwrite.writebit(bit) bitwrite.flush() pass
def compress(tree, uncompressed, compressed): ''' First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' bitreader = bitio.BitReader(uncompressed) bitwriter = bitio.BitWriter(compressed) # write tree to the beginning of the file write_tree(tree, bitwriter) # create encoding table for compressed bits of file using our tree table = huffman.make_encoding_table(tree) counter = 0 # read from uncompressed stream until done while True: try: # find path description (tuple) from encoding table path = table[bitreader.readbits(8)] # if we have reached the end of the file except EOFError: bitwriter.writebits(0, 2) # to have a full byte at the end counter += 2 break # write the path to the compressed file for p in path: if p: bitwriter.writebit(1) counter += 1 else: bitwriter.writebit(0) counter += 1 # find how many bits left to make an even byte counter %= 8 # complete byte with 0s while counter: bitwriter.writebit(0) counter -= 1
def binaryDump(filename): bits = [] with open(filename, "rb") as f: b = bitio.BitReader(f) while True: newBit = b.readbits(1) bits.append(newBit) if not b.read: break return bits
def decompress(compressed, uncompressed): bitreader = bitio.BitReader(compressed) bitwriter = bitio.BitWriter(uncompressed) tree = read_tree(bitreader) # Repeatedly read coded bits from the file, decode them using tree while True: decoded = huffman.decode(tree, bitreader) # As soon as you decode the end-of-message symbol, you should stop reading. if decoded is None: break # write the decoded byte to the uncompressed output bitwriter.writebits(decoded, 8)
def compress(tree, uncompressed, compressed): """First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the BitWriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. """ def read_byte(bit_stream): """ Short function to read the file, just to allow for use of iter(), decreasing clutter :param bit_stream: a BitReader object :return: None when EOF, the byte read otherwise. """ try: return bit_stream.readbits(8) except EOFError: return None write_tree(tree, compressed) encoding_table = huffman.make_encoding_table(tree) # Open a BitReader for uncompressed file in_stream = bitio.BitReader(uncompressed) output = [] # Read the uncompressed file until EOF for uncompressed_byte in iter(lambda: read_byte(in_stream), None): compressed_byte = encoding_table[uncompressed_byte] output += list(compressed_byte) # Add EOF output += list(encoding_table[None]) # Open BitWriter for compressed file out_stream = bitio.BitWriter(compressed) # Write out bits for bit in output: out_stream.writebit(bit) # Flush stream out_stream.flush()
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' bitwriter = bitio.BitWriter(compressed) bitreader = bitio.BitReader(uncompressed) # table maps the byte of a leaf node to a tuple containiing the bit sequence table = huffman.make_encoding_table(tree) write_tree(tree, bitwriter) # holds the bits written to the compressed stream bit_count = 0 # read bits from the uncompressed stream until there are none left while True: try: symbol = bitreader.readbits(8) except: break # write the bit sequence for the symbol read encoded = table[symbol] for bit in encoded: bit_count += 1 bitwriter.writebit(bit) # write the end of file message for bit in table[None]: bit_count += 1 bitwriter.writebit(bit) # pad with zeros if there are partial bytes remaining = bit_count % 8 if remaining != 0: for i in range(remaining): bitwriter.writebit(False) bitwriter.flush()
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' # instances of the BitReader and BitWriter reader = bitio.BitReader(uncompressed) writer = bitio.BitWriter(compressed) # make the encoding table for the given tree encode_table = huffman.make_encoding_table(tree) # call write_tree, to write the tree to the compressed file write_tree(tree, writer) # write all the bytes untill EOFError occurs while True: try: # read the byte from uncompressed file byte_towrite = reader.readbits(8) # encode the byte using the dictionary bit_sequence = encode_table[byte_towrite] # write each bit to the compressed file for b in bit_sequence: if b == True: writer.writebit(1) elif b == False: writer.writebit(0) except EOFError: bit_sequence = encode_table[None] # write each bit to the compressed file for b in bit_sequence: if b == True: writer.writebit(1) elif b == False: writer.writebit(0) # stop the loop break # Flush the bitwriter writer.flush()
def decompress(compressed, uncompressed): #defining reader and writer bitreader1 = bitio.BitReader(compressed) bitwriter1 = bitio.BitWriter(uncompressed) tree = read_tree(compressed) alphabet = 0 while alphabet!=None: letter = decode_byte(tree, bitreader1) bitwriter1.writebits(letter, 8) bitwriter1.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' '''br = BitReader(compressed) tree = read_tree(br) print(tree.left.left.left.left.left) # encoded_table = huffman.make_encoding_table(tree) # print(encoded_table) # print(bin(br.readbits(100))) bw = BitWriter(uncompressed) while True: try: bit = br.readbit() byte = decode_byte(tree, br) bw.writebits(byte, 8) except EOFError: break bw.writebit(0b0) bw.writebit(0b1) bw.writebit(0b0) bw.writebit(0b1) bw.writebit(0b0) bw.writebit(0b0) bw.writebit(0b1) bw.writebit(0b0)''' # initialize the reading and writing reader = bitio.BitReader(compressed) writer = bitio.BitWriter(uncompressed) tree = read_tree(reader) while 1: byte = decode_byte(tree, reader) if byte == None: # means ending break else: writer.writebits(byte, 8)
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' # initialise tables and input and output bitstreams table = huffman.make_encoding_table(tree) input_stream = bitio.BitReader(uncompressed) output_stream = bitio.BitWriter(compressed) write_tree(tree, output_stream) # set up a counter to find partially filled bytes counter = 0 while (True): try: # tries to read 8 bytes, if end of file found, go to except byte = input_stream.readbits(8) path = table[byte] # find the path counter += len(path) for i in path: # output the bits output_stream.writebit(i) except: # for partially filled bytes, pad with 0's to make a byte path = table[None] # find the path counter += len(path) for i in path: # output the bits output_stream.writebit(i) output_stream.writebits(0, counter % 8) # flush output_stream.flush() return
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' # create tree using read_tree try: tree = read_tree(compressed) except: print("Huffman tree description invalid") return # open using bitio bitread = bitio.BitReader(compressed) bitwrite = bitio.BitWriter(uncompressed) # attempt to decode file bits after Huffman tree description try: decode = decode_byte(tree, bitread) except EOFError: decode = None print("No bits to read after Huffman tree description") # if bits are successfully decoded, begin writing them, till EOF is reached while decode != None: try: # write decoded symbol with 8 bits and decode the next bits bitwrite.writebits(decode, 8) decode = decode_byte(tree, bitread) # exception in case compressed file does not have None written before EOF except EOFError: decode = None pass
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' # Same initial setup as decompress reader = bitio.BitReader(uncompressed) writer = bitio.BitWriter(compressed) # This time we are writing the tree instead write_tree(tree, writer) # key is a dictionary that is used to find the specific bitsequence for a # specific byte using the huffman coding key = huffman.make_encoding_table(tree) while 1: try: # use the key to map the specific byte to the corresponding # huffman bitsequence. By looping through the whole file, we can # compress every byte to a huffman compressed bit sequence, thus # compressing the whole file to a .huff extension byte = reader.readbits(8) bitsequence = key[byte] for bit in bitsequence: writer.writebit(bit) # This flag is hear to indicate we have reached the end of the file # and to thus stop compressing except EOFError: break pass
def compress(tree, uncompressed, compressed): '''First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' ##let compressed be an instance of bitio.BitWriter Target = bitio.BitWriter(compressed) #let uncompressed be an instance of bitio.BitReader readingfile = bitio.BitReader(uncompressed) #Write the Huffman tree to compressed file. write_tree(tree, Target) #to get encoding table encode = huffman.make_encoding_table(tree) while True: # try EOFError try: # can read a byte ? reading = readingfile.readbits(8) except EOFError: # reach EOF encode eof,then get out of loop Target.writebit(0) Target.writebit(0) break #if no EOFError, get the sequence from tree using encoding table value = encode[reading] for v in value: # write v as a bit Target.writebit(v) Target.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' bitstream = bitio.BitReader(compressed) # Gets bits from compressed tree = read_tree(bitstream) # Produce tree based on bit sequence while True: # Do final decoding of tree based on remaining bits val = huffman.decode(tree, bitstream) if val is None: # Stop at endLead break else: # Write the stored values in the tree (ordered by bit sequence) uncompressed.write(bytes([val])) # as a byte in uncompressed
def compress(tree, uncompressed, compressed): ''' First write the given tree to the stream 'compressed' using the write_tree function. Then use the same tree to encode the data from the input stream 'uncompressed' and write it to 'compressed'. If there are any partially-written bytes remaining at the end, write 0 bits to form a complete byte. Flush the bitwriter after writing the entire compressed file. Args: tree: A Huffman tree. uncompressed: A file stream from which you can read the input. compressed: A file stream that will receive the tree description and the coded input data. ''' # The given tree is written to the compressed write_tree(tree, compressed) # The bit writer object is created compressed_ = bitio.BitWriter(compressed) # The bit reader object is created uncompressed_ = bitio.BitReader(uncompressed) # Encoding table is made here encoding_table = huffman.make_encoding_table(tree) flag1 = 1 while flag1 == 1: # To catch the End of File error try: # Reading 8 bits (byte) current_bits = uncompressed_.readbits(8) # These are stored in an encoding table compressed1 = encoding_table[current_bits] for bits in compressed1: compressed_.writebit(bits) except EOFError: for bits in encoding_table[None]: compressed_.writebit(bits) # Where the while loop will end flag1 = 0 compressed_.flush()
def decompress(compressed, uncompressed): '''First, read a Huffman tree from the 'compressed' stream using your read_tree function. Then use that tree to decode the rest of the stream and write the resulting symbols to the 'uncompressed' stream. Args: compressed: A file stream from which compressed input is read. uncompressed: A writable file stream to which the uncompressed output is written. ''' # get bits from compressed file stream and use it to get tree inputstream = bitio.BitReader(compressed) tree = read_tree(inputstream) while True: # repeatedly read coded bits from file and decode them using tree decoded_bytes = decode_byte(tree, inputstream) if decoded_bytes == None: break else: # write bits to uncompressed file uncompressed.write(bytes([decoded_bytes]))