Convert very large base number n to bytes

I have a very large number in a database n

( n

user supplied) stored as an array with each element representing a digit. u[0]

- the highest digit, u[1]

- the second largest, u[-1]

- the least significant digit, and so on. Leading zeros are understood to be meaningless: for example, if n

is 8, it is [0, 0, 0, 4, 7, 3]

equivalent [4, 7, 3]

and both are (473) in base 8 or 315 in base 10, either 13B

in hexadecimal, or [1, 59]

as a byte array.

I want to convert this to an array of bytes that match the base-256 representation of the same number with minimal leading zeros. I have the following code:

def base_n_to_byte_array(digits, from_base):
    """ Converts a base n number to a byte array.

    :param digits: Digits of the number, starting from highest.
    :param from_base: Base in which the number is given.
    """

    x = 0
    n = len(digits)
    for i in range(0, len(digits)):
        x += digits[i] * int(math.pow(from_base, n - i - 1))

    min_length = max(math.ceil(math.log(x, 256)), 1)
    byte_array = x.to_bytes(min_length, byteorder='big')
    return byte_array

      

        
        
        
      

    

This works for smaller numbers (several hundred digits). However, it turns out to be math.pow

quite limited, for example if we use base 8 math.pow(8, 341)

is the highest cardinality I can get while math.pow(8,342)

failing with OverflowError: math range error

.

I know that the general way to work with large numbers is to represent them as floating points, but in this case, I use this code to encode / decode binaries into alternate representations (like trytes). Therefore, if less significant bytes change due to loss of precision, most of the data will be corrupted, so I cannot use a rough calculation of the cardinality - I need the result to be accurate.

How can I solve this problem? Is there a version math.pow

that doesn't overflow? Is there a better database conversion algorithm that I am overlooking?