How to convert integer sizes and pointer declarations from C++ to Python?

I am trying to convert this C++ function into Python code but I am having trouble in doing so for the pointer and turning the python variables into uint32_t and uint8_t respectively. I am not sure how to declare the functions such that it returns uint32_t and also what to do with the pointer uint8_t *buf. Please help me in figuring out on how to convert the function, from C++ to python.

This is my C++ code:

uint32_t Functions::Do_calc(uint8_t *buf, uint32_t len){
    return Do_calc(25, buf, len);
}

uint32_t Functions::Do_calc(uint32_t val, uint8_t *buf, uint32_t len){
    uint32_t temp_int, c = val;
    uint32_t ip_buf[128];
    uint32_t j, rem = 0, tf = 0, p = 0;

    rem = len;
    while(rem > 0){
        if(rem <= 512){
            tf = rem;
        }
        else{
            tf = 512;
        }

        for(j = 0; j < 128; j++){
            ip_buf[j]=0;
        }

        for(j = 0; j < tf; j += 2){
            temp = ((buf[p * 512 + (j + 3)]<<24) +
                (buf[p * 512 + (j + 2)]<<16) +
                (buf[p * 512 + (j + 1)]<<8) +
                buf[p * 512 + j]);
            ip_buf[j / 4] = temp;
        }

        c = c_cal(ip_buf, tf, c, 0x04C22AB9, 2, true);
        p++
    }

    return c;
}


uint32_t Functions::c_cal(uint32_t *d_base, uint32_t d_size, uint32_t c, uint32_t poly, uint8_t c_size, bool b_r_ip)
{
    unsigned long d_offset;
    unsigned long d, d_temp;
    unsigned char c_bit;

    d = 0;
    for(d_offset = 0; d_offset < d_size; (d_offset += c_size))
    {
        u32_d_temp = 0;
        d_temp = d_base[d_offset/c_size];
        if(FALSE == b_r_ip)
        {
            d = d_temp;
        }
        else
        {
            d = 0;
            for(c_bit = 0; c_bit < (c_size << 3); c_bit++)
            {
                d <<= 1;
                d |= (d_temp & 1);
                d_temp >>= 1;
            }
        }

        for(c_bit = 0; c_bit < (c_size << 3); c_bit++)
        {
            if(((c >> ((c_size << 3) - 1)) ^ d) & 1)
            {
                c <<= 1;
                d >>= 1;
                c ^= poly;
            }
            else
            {
                c <<= 1;
                d >>= 1;
            }
        }
    }

    return (c & (0xFFFFFFFF >> (32 - (c_size << 3))));
}

This is my attempted Python implementation. As you can see I just did a basic implementation as I did not worry about the pointer and the size of the integer which is very much needed:

def Do_calc(buf, len):
    return Do_calc(0, buf, len)

def Do_calc(val, buf, len):
    ip_buf = []
    c = val
    p = 0
    rem = len

    while rem > 0:
        if rem <= 512:
            tf = rem
        else:
            tf = 512

        for j in range(128):
            ip_buf[j].append = 0

        for j in xrange(0, tf, 2):
            temp_int = ((buffer[packet * 512 + (i + 3)] << 24) +
                (buffer[packet * 512 + (i + 2)] << 16) +
                (buffer[packet * 512 + (i + 1)] << 8) +
                buffer[packet * 512 + i])
            ip_buf[j/4] = temp

        c = c_cal(ip_buf, tf, c, 0x04C22AB9, 2, true)
        p += 1
     

    return c

How do I properly do the conversion after taking care of all the aspects?