Адаптивное арифметическое кодирование на Python

import pickle
 
class ArithmeticCoding:
    def __init__(self, AlphPower, FirstCode, CodingLength):
        self.AlphPower = AlphPower
        self.FirstCode = FirstCode
        self.CodingLength = CodingLength
 
    def count_file_symbols(self, filename):
        symbol_count = 0
        ents = [0] * (self.AlphPower + 1)
        input_file = open(filename, 'r')
        for line in input_file:
            for char in line:
                char_code = ord(char)
                if char_code < self.AlphPower:
                    ents[char_code] = ents[char_code] + 1
                else:
 
                    ents.append(0)
                    self.AlphPower += 1
                    ents[char_code] = ents[char_code] + 1
                symbol_count = symbol_count + 1
        input_file.close()
        return symbol_count, ents
 
    def init_model(self, inputFilename, outputFilename):
        (symbol_count, ents) = self.count_file_symbols(inputFilename)
        for char_code in range(self.FirstCode, self.AlphPower):
            ents[char_code] = 1.0 * ents[char_code] / symbol_count
        low = 0.0
        dic = {}
        for char_code in range(self.FirstCode, self.AlphPower):
            if ents[char_code] > 0:
                high = low + ents[char_code]
                dic[char_code] = (low, high)
                low = high
        model_file = open(outputFilename, 'wb')
        pickle.dump(dic, model_file)
        model_file.close()
 
    def read_model(self, modelFilename):
        input_file = open(modelFilename, 'rb')
        dic = pickle.load(input_file)
        input_file.close()
        return dic
 
    def char_low_high(self, char, dic):
        char_code = ord(char)
        (low, high) = dic[char_code]
        return (low, high)
 
    def add_symbol_to_coding_sequence(self, seq_low, seq_high, dic, symbol):
        (symbol_low, symbol_high) = self.char_low_high(symbol, dic)
        return (seq_low + (seq_high - seq_low) * symbol_low,
                seq_low + (seq_high - seq_low) * symbol_high)
 
    def AriphCoding(self, input_filename, dic, outputfilename):
        input_file = open(input_filename, 'r')
        output_file = open(outputfilename, 'wb')
        coding_result = []
        count = self.CodingLength + 1
        for line in input_file:
            for char in line:
                if count >= self.CodingLength:
                    (low, high) = self.char_low_high(char, dic)
                    count = 1
                else:
                    (low, high) = self.add_symbol_to_coding_sequence(low, high, dic, char)
                    count = count + 1
                if count >= self.CodingLength:
                    coding_result.append((count, low+(high-low)/2))
        if count != 0:
            coding_result.append((count, low + (high - low) / 2))
        pickle.dump(coding_result, output_file)
        input_file.close()
        output_file.close()
 
    def reverse_map(self, char_to_range):
        range_to_char = {}
        for key in char_to_range:
            ranger = char_to_range[key]
            range_to_char[ranger] = key
        return range_to_char
 
    def get_first_char_range(self, value, range_to_char):
        for key in range_to_char:
            ranger = key
            if ranger[0] <= value <= ranger[1]:
                return ranger
        return [-1, -1]
 
    def AriphDecoding(self, input_filename, range_to_char, outputfilename):
        input_file = open(input_filename, 'rb')
        codes = pickle.load(input_file)
        input_file.close()
        output_file = open(outputfilename, 'w')
        for (length, code) in codes:
            for number in range(length):
                char_range = self.get_first_char_range(code, range_to_char)
                char = range_to_char[char_range]
                output_file.write(chr(char))
                (low, high) = char_range
                code = (code-low)/(high-low)
        output_file.close()
 
coding = ArithmeticCoding(255, 0, 5)
choice = int(input("Do you want to encode(0) or decode(1): "))
if choice == 0:
    file_1 = input("Enter the file you want to encode: ")
    file_2 = input("Enter the file you want to write this to: ")
    coding.init_model(file_1, 'ents.txt')
    char_to_range = coding.read_model('ents.txt')
    range_to_char = coding.reverse_map(char_to_range)
    coding.AriphCoding(file_1, char_to_range, file_2)
else:
    file_1 = input("Enter the file you want to decode: ")
    file_2 = input("Enter the file you want to write this to: ")
    char_to_range = coding.read_model('ents.txt')
    range_to_char = coding.reverse_map(char_to_range)
    coding.AriphDecoding(file_1, range_to_char, file_2)