Python + Go: Examples

lib.go

// # Functions
//
// # Convert C types to go types (internal; Use at entrypoint to Go libraries)
//
//	CStringToString(input *C.char) string{} //Convert a string to a c-compatible C-string (glorified alias for C.GoString)
//	CFloatArrayToSlice(cArray *C.float, length int) []float32{} // Converts a C array of floats to a slice of floats
//	CIntArrayToSlice(cArray *C.int, length int) []int{} // Takes a C integer array and coverts it to an integer slice
//	CStringArrayToSlice(cArray **C.char, numberOfStrings int) []string{} // Takes in an array of strings, and converts it to a slice of strings
//
// # Convert Go types to C types (external; Use to prep data to return to C)
//
//	StringToCString(data string) *C.char{} // Convert a string to a c-compatible C-string (glorified alias for C.CString)
//	StringSliceToCArray(data []string) *C.StringArrayResult{} // Return dynamically sized string array as a C-Compatible array
//	IntSliceToCArray(data []int) *C.IntArrayResult{} // Return dynamically sized int array as a C-Compatible array
//	FloatSliceToCArray(data []float32) *C.FloatArrayResult{} // Return dynamically float sized array as a C-Compatible array
//
// # Memory Freeing
//
//	FreeCString(data *C.char){} // Free's a C-string
//	FreeStringArray(inputArray **C.char, count C.int){} // Free's an array of strings
//	FreeIntArray(ptr *C.int){}  // Free's an array of integers
//	FreeFloatArray(ptr *C.float){} // Free's an array of floats
//
// # Debugging Functions
//
//	return_string(data *C.char) *C.char{} // Used to convert a C-compatible string to a C-compatible string, useful for debugging encoding issues
//	return_string_array(cArray **C.char, numberOfStrings int) *C.StringArrayResult{} // Used to convert a C-compatible string array to wrapper type
//	return_int_array(cArray *C.int, numberOfElements C.int) *C.IntArrayResult{} // Used to convert a C-compatible integer array to wrapper type
//	return_float_array(cArray *C.float, numberOfElements C.int) *C.FloatArrayResult{} // Used to convert a C-compatible float array to wrapper type
//	print_string(ptr *C.char){} // Prints the go representation of a C string, good for debugging encoding issues
//	print_string_array(cArray **C.char, numberOfString int){} // Prints the go representation of an array, good for debugging encoding issues
//	print_int_array(cArray *C.int, numberOfInts int){} // Prints the go representation of an array, good for debugging rounding/conversion issues
//	print_float_array(cArray *C.float, numberOfFloats int){} // Prints the go representation of an array, good for debugging rounding/conversion issues
//
// # Examples
//
// Create a function to show the internal go representation of an array of strings
//
//	 // Takes in a C string array, prints the go representation, then returns it
//	 //export print_string_array
//	 func print_string_array(cArray **C.char, numberOfStrings int) *C.StringArrayResult {
//		  internalRepresentation := CStringArrayToSlice(cArray, numberOfStrings)
//		  fmt.Printf("return_string_array() Go representation: %v\n", internalRepresentation)
//
//		  result := StringSliceToCArray(internalRepresentation)
//
//		  return result
//	 }
package main

/*
#include <stdlib.h>

typedef struct{
	int numberOfElements;
	char** data;
} StringArrayResult;

typedef struct {
    int numberOfElements;
    int* data;
} IntArrayResult;

typedef struct {
    int numberOfElements;
    float* data;
} FloatArrayResult;

*/
import "C"
import (
	"fmt"
	"unsafe"
)

// ======== Convert Go types to C type ========

// Convert a string to a c-compatible C-string (glorified alias for C.CString)
//
// Parameters:
//   - input: The Go string to convert.
//
// Returns:
//   - A pointer to the newly allocated C string (*C.char).
//     Note: The caller is responsible for freeing the allocated memory using FreeCString.
func StringToCString(input string) unsafe.Pointer {
	return unsafe.Pointer(C.CString(input))
}

// A function to take a slice and convert it to a StringArrayResult to be returned to C code
//
// Parameters:
//   - data: Slice of Go strings to convert.
//
// Returns:
//   - Pointer to a C.StringArrayResult containing the converted C strings.
//     Note: The caller is responsible for freeing the allocated memory using free_string_array_result.
func StringSliceToCArray(data []string) *C.StringArrayResult {
	count := len(data)

	// Allocate memory for an array of C string pointers (char**)
	amountOfElements := C.size_t(count)
	sizeOfSingleElement := C.size_t(unsafe.Sizeof(uintptr(0)))
	amountOfMemory := amountOfElements * sizeOfSingleElement
	stringArray := (**C.char)(C.malloc(amountOfMemory))

	// Create Array of data
	for i, currentString := range data {
		// Calculate where to put the string
		locationOfArray := uintptr(unsafe.Pointer(stringArray)) // Starting point of first byte of slice
		offsetIntoArray := uintptr(i)                           // The offset for the current element
		sizeOfSingleElement := unsafe.Sizeof(uintptr(0))        // Size of a single string

		locationInMemory := (**C.char)(unsafe.Pointer(locationOfArray + offsetIntoArray*sizeOfSingleElement))
		*locationInMemory = C.CString(currentString) // Convert go string to C string and insert at location in array

	}

	// Allocate memory for the struct
	result := (*C.StringArrayResult)(C.malloc(C.size_t(unsafe.Sizeof(C.StringArrayResult{}))))
	result.numberOfElements = C.int(count)
	result.data = stringArray

	return result
}

// Return dynamically sized int array as a C-Compatible array
//
// Parameters:
//   - data: Slice of Go integers to convert.
//
// Returns:
//   - Pointer to a C.IntArrayResult containing the converted C integers.
//     Note: The caller is responsible for freeing the allocated memory using free_int_array_result.
func IntSliceToCArray(data []int) *C.IntArrayResult {
	count := len(data)

	// Allocate memory in C for the int array
	amountOfMemory := C.size_t(count) * C.size_t(unsafe.Sizeof(C.int(0)))
	cArray := (*C.int)(C.malloc(amountOfMemory))

	// Fill in the values
	array := (*[1 << 30]C.int)(unsafe.Pointer(cArray))
	for i, val := range data {
		array[i] = C.int(val)
	}

	// Allocate the result struct
	result := (*C.IntArrayResult)(C.malloc(C.size_t(unsafe.Sizeof(C.IntArrayResult{}))))
	result.numberOfElements = C.int(count)
	result.data = cArray

	return result
}

// Return dynamically float sized array as a C-Compatible array
//
// Parameters:
//   - data: Slice of Go float32 values to convert.
//
// Returns:
//   - Pointer to a C.FloatArrayResult containing the converted C floats.
//     Note: The caller is responsible for freeing the allocated memory using free_float_array_result.
func FloatSliceToCArray(data []float32) *C.FloatArrayResult {
	count := len(data)

	// Allocate memory in C for the float array
	amountOfMemory := C.size_t(count) * C.size_t(unsafe.Sizeof(C.float(0)))
	cArray := (*C.float)(C.malloc(amountOfMemory))

	// Fill in the values
	array := (*[1 << 30]C.float)(unsafe.Pointer(cArray))
	for i, val := range data {
		array[i] = C.float(val)
	}

	// Allocate the result struct
	result := (*C.FloatArrayResult)(C.malloc(C.size_t(unsafe.Sizeof(C.FloatArrayResult{}))))
	result.numberOfElements = C.int(count)
	result.data = cArray

	return result
}

// ======== Convert C types to Go ========

// Convert a string to a c-compatible C-string (glorified alias for C.GoString)
//
// Parameters:
//   - input: Pointer to the C string to convert (*C.char).
//
// Returns:
//   - The corresponding Go string.
func CStringToString(input unsafe.Pointer) string {
	return C.GoString((*C.char)(input))
}

// Takes a C integer array and coverts it to an integer slice
//
// Parameters:
//   - cArray: Pointer to the C array of integers (*C.int).
//   - length: Number of elements in the C array.
//
// Returns:
//   - A Go slice containing the converted integers.
//
// Usage:
//
//	var cIntArray *C.int // Assuming it's set in some line after this
//	goInts := CIntArrayToSlice(unsafe.Pointer(cIntArray), length)
func CIntArrayToSlice(cArray unsafe.Pointer, length int) []int {
	// Setup buffer for array contents
	const bufferSize = 1 << 30 // Allocate a huge buffer
	slice := (*[bufferSize]C.int)(cArray)[:length:length]

	// Convert to []int
	result := make([]int, length)
	for i := 0; i < length; i++ {
		result[i] = int(slice[i])
	}
	return result
}

// Converts a C array of floats to a slice of floats
//
// Parameters:
//   - cArray: Pointer to the C array of floats (*C.float).
//   - length: Number of elements in the C array.
//
// Returns:
//   - A Go slice containing the converted float32 values.r
//
// Usage:
//
//	var cFloatArray  *C.float // Assuming it's set in some line after this
//	goFloats := CFloatArrayToSlice(unsafe.Pointer(cFloatArray), length)
func CFloatArrayToSlice(cArray unsafe.Pointer, length int) []float32 {
	// Setup buffer for array contents
	const bufferSize = 1 << 30 // Allocate a huge buffer
	slice := (*[bufferSize]C.float)(cArray)[:length:length]

	// Convert to []float32
	result := make([]float32, length)
	for i := 0; i < length; i++ {
		result[i] = float32(slice[i])
	}
	return result
}

// Takes in an array of strings, and converts it to a slice of strings
// C array -> slice of strings
//
// Parameters:
//   - cArray: Pointer to the C array of strings (**C.char).
//   - numberOfStrings: Number of strings in the C array.
//
// Returns:
//   - A Go slice containing the converted strings.
//
// Notes
//
//   - This function DOES NOT clean memory of input array, that's up to others to clear
func CStringArrayToSlice(cArray unsafe.Pointer, numberOfStrings int) []string {
	// Setup buffer for array contents
	const bufferSize = 1 << 30 // Allocate a huge buffer
	stringPointers := (*[bufferSize]*C.char)(cArray)[:numberOfStrings:numberOfStrings]

	result := make([]string, 0, numberOfStrings)
	for i := range numberOfStrings {
		result = append(result, C.GoString(stringPointers[i]))
	}
	return result
}

// ========== Debugging Functions ==========

// Used to convert a C-compatible string back to itself, good for debugging encoding issues
//
// Parameters:
//   - cString: Pointer to the C string (*C.char).
//
// Returns:
//   - Pointer to a new C string with the same content (*C.char).
//     Note: The caller is responsible for freeing the allocated memory using FreeCString.
//
//export return_string
func return_string(cString unsafe.Pointer) unsafe.Pointer {
	internalRepresentation := C.GoString((*C.char)(cString))
	result := StringToCString(internalRepresentation)
	return result
}

// Used to convert a C-compatible string array to wrapper type
//
// Parameters:
//   - cArray: Pointer to the C array of strings (**C.char).
//   - numberOfStrings: Number of strings in the C array.
//
// Returns:
//   - Pointer to a C.StringArrayResult containing the converted strings (*C.StringArrayResult).
//     Note: The caller is responsible for freeing the allocated memory using free_string_array_result.
//
//export return_string_array
func return_string_array(cArray unsafe.Pointer, numberOfStrings int) *C.StringArrayResult {

	internalRepresentation := CStringArrayToSlice(cArray, numberOfStrings)

	result := StringSliceToCArray(internalRepresentation)

	return result
}

// Used to convert a C-compatible integer array to wrapper type
//
// Parameters:
//   - cArray: Pointer to the C array of integers (*C.int).
//   - numberOfElements: Number of elements in the C array.
//
// Returns:
//   - Pointer to a C.IntArrayResult containing the converted integers (*C.IntArrayResult).
//     Note: The caller is responsible for freeing the allocated memory using free_int_array_result.
//
//export return_int_array
func return_int_array(cArray unsafe.Pointer, numberOfElements C.int) *C.IntArrayResult {
	internalRepresentation := CIntArrayToSlice(cArray, int(numberOfElements))
	result := IntSliceToCArray(internalRepresentation)
	return (*C.IntArrayResult)(result)
}

// Used to convert a C-compatible float array to wrapper type
//
// Parameters:
//   - cArray: Pointer to the C array of floats(*C.float).
//   - numberOfElements: Number of elements in the C array.
//
// Returns:
//   - Pointer to a C.FloatArrayResult containing the converted floats (*C.FloatArrayResult).
//     Note: The caller is responsible for freeing the allocated memory using free_float_array_result.
//
//export return_float_array
func return_float_array(cArray unsafe.Pointer, numberOfElements C.int) *C.FloatArrayResult {
	internalRepresentation := CFloatArrayToSlice(cArray, int(numberOfElements))
	result := FloatSliceToCArray(internalRepresentation)
	return (*C.FloatArrayResult)(result)
}

// Prints the go representation of a C string, good for debugging encoding issues
//
// Parameters:
//   - ptr: Pointer to the C string (*C.char).
//
//export print_string
func print_string(ptr unsafe.Pointer) {
	if ptr != nil {
		fmt.Printf("print_string() Go representation: %s\n", C.GoString((*C.char)(ptr)))
	} else {
		fmt.Println("print_string() received nil pointer")
	}
}

// Prints the go representation of an array, good for debugging encoding issues
//
// Parameters:
//   - cArray: Pointer to the C array of strings (**C.char).
//   - numberOfString: Number of strings in the C array.
//
//export print_string_array
func print_string_array(cArray unsafe.Pointer, numberOfString int) {
	res := CStringArrayToSlice(cArray, numberOfString)
	fmt.Printf("print_string_array() Go representation: %v\n", res)
}

// Prints the go representation of an array, good for debugging rounding/conversion issues
//
// Parameters:
//   - cArray: Pointer to the C array of integers (*C.int).
//   - numberOfInts: Number of integers in the C array.
//
//export print_int_array
func print_int_array(cArray unsafe.Pointer, numberOfInts int) {
	fmt.Printf("Got initial array with %d items, converting", numberOfInts)
	res := CIntArrayToSlice(cArray, numberOfInts)
	fmt.Println("Converted array")

	fmt.Printf("print_int_array() Go representation: %v\n", res)
}

// Prints the go representation of an array, good for debugging rounding/conversion issues
//
// Parameters:
//   - cArray: Pointer to the C array of floats (*C.float).
//   - numberOfFloats: Number of floats in the C array.
//
//export print_float_array
func print_float_array(cArray unsafe.Pointer, numberOfFloats int) {
	res := CFloatArrayToSlice(cArray, numberOfFloats)

	fmt.Printf("print_float_array() Go representation: %v\n", res)
}

// ========== Functions to free memory ==========

// Free a previously allocated C string from Go.
//
// Parameters:
//   - ptr: Pointer to the C string to be freed (*C.char).
//
//export FreeCString
func FreeCString(ptr unsafe.Pointer) {
	if ptr != nil {
		C.free(ptr)
	}
}

// Free a StringArrayResult allocated by StringSliceToCArray.
//
// Parameters:
//   - result: Pointer to the C.StringArrayResult to be freed (**C.char).
//
//export FreeStringArray
func FreeStringArray(inputArray unsafe.Pointer, count C.int) {
	for i := 0; i < int(count); i++ {
		// Calculate where to find the string
		locationOfArray := uintptr(inputArray)          // Starting point of first byte of slice
		offsetIntoArray := uintptr(i)                   // The offset for the current element
		memorySizeOfStruct := unsafe.Sizeof(uintptr(0)) // Size of a single struct

		ptr := *(**C.char)(unsafe.Pointer(locationOfArray + offsetIntoArray*memorySizeOfStruct))
		C.free(unsafe.Pointer(ptr))
	}
	C.free(inputArray)
}

// Free an *C.int.
//
// Parameters:
//   - result: Pointer to the *C.int to be freed.
//
//export FreeIntArray
func FreeIntArray(ptr unsafe.Pointer) {
	C.free(ptr)
}

// Free a *C.float.
//
// Parameters:
//   - result: Pointer to the C.FloatArrayResult to be freed (*C.float).
//
//export FreeFloatArray
func FreeFloatArray(ptr unsafe.Pointer) {
	C.free(ptr)
}

// Free a *C.StringArrayResult.
//
// Parameters:
//   - result: Pointer to the C.StringArrayResult to be freed (*C.StringArrayResult).
//
//export free_string_array_result
func free_string_array_result(StringArrayResultReference unsafe.Pointer) {
	temp := (*C.StringArrayResult)(StringArrayResultReference)
	FreeStringArray(unsafe.Pointer(temp.data), temp.numberOfElements)
	C.free(unsafe.Pointer(StringArrayResultReference))
}

// Free a *C.IntArrayResult.
//
// Parameters:
//   - result: Pointer to the C.IntArrayResult to be freed (*C.IntArrayResult).
//
//export free_int_array_result
func free_int_array_result(ptr unsafe.Pointer) {
	temp := (*C.IntArrayResult)(ptr)
	FreeIntArray(unsafe.Pointer(temp.data))
	C.free(unsafe.Pointer(ptr))
}

// Free a *C.FloatArrayResult.
//
// Parameters:
//   - result: Pointer to the C.FloatArrayResult to be freed (*C.FloatArrayResult).
//
//export free_float_array_result
func free_float_array_result(ptr unsafe.Pointer) {
	temp := (*C.FloatArrayResult)(ptr)
	FreeFloatArray(unsafe.Pointer(temp.data))
	C.free(unsafe.Pointer(ptr))
}

func main() {}

lib.py

"""A package to help with building Go-python libraries"""
import os
import subprocess
from platform import platform
from ctypes import CDLL, Array, cdll, c_char_p, c_int, POINTER, c_float, Structure, string_at 

# ========== Helper Functions  ============
def get_library(dll_path:str,source_path:str="", compile:bool=False) -> CDLL:
    """Get's the DLL specified, will compile if not found and flag is specified

    Parameters
    ----------
    dll_path : str
        The path to the DLL file, if compile is specified this will be the output path

    source_path:str, optional
        The path to the source go file, only needed if compile is true, by default ""

    compile : bool, optional
        Specify if you should try to compile DLL if not in path, by default False

    Raises
    ------
    ValueError:
        If linked library is not available and/or compilable (if compile is specified)

    Returns
    -------
    CDLL
        The linked library
        
    Examples
    --------
    Build similarity.dll/similarity.so from lib.go
    
    from platform import platform
    # import library
    if platform().lower().startswith("windows"):
        library_location = os.path.join(os.path.dirname(os.path.realpath(__file__)), "similarity.dll")
    else:
        library_location = os.path.join(os.path.dirname(os.path.realpath(__file__)), "similarity.so")

    source_location = os.path.join(os.path.dirname(os.path.realpath(__file__)), "lib.go")
    
    lib = get_library(library_location, source_location, compile=True)
    
    """
    if not os.path.exists(dll_path):
        if not compile:
            raise ValueError(f"Linked Library is not available: {dll_path}")
        if platform().lower().startswith("windows"):
            additional_flags = "set GOTRACEBACK=system &&"
        else:
            additional_flags = "env GOTRACEBACK=system"
        command = f"{additional_flags} go build -ldflags \"-s -w\" -buildmode=c-shared -o \"{dll_path}\""
        if compile:
            print("\nRequired shared library is not available, building...")
            try:
                subprocess.run(command, shell=True, check=True, cwd=os.path.dirname(source_path))
            except Exception as e:
                if isinstance(e, FileNotFoundError):
                    print("Unable to find Go install, please install it and try again\n")
                else:
                    print(f"Ran into error while trying to build shared library, make sure go, and a compatible compiler are installed, then try building manually using:\n\t{command}\nExiting with error:\n\t{e}")
                raise ValueError(f"Linked Library is not available or compileable: {dll_path}")
    return cdll.LoadLibrary(dll_path)

# ========== C Structs ==========
class _CStringArrayResult(Structure):
    _fields_ = [
        ("numberOfElements", c_int),
        ("data", POINTER(c_char_p)),
    ]
    
class _CIntArrayResult(Structure):
    _fields_ = [
        ("numberOfElements", c_int),
        ("data", POINTER(c_int)),
    ]

class _CFloatArrayResult(Structure):
    _fields_ = [
        ("numberOfElements", c_int),
        ("data", POINTER(c_float)),
    ]

# ========== Setup CGo functions ==========

# import library
dll_source_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "lib.go")
if platform().lower().startswith("windows"):
    dll_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),"lib.dll")
    lib = get_library(dll_file, dll_source_file, True)
else:
    dll_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),"lib.so")
    lib = get_library(dll_file, dll_source_file, True)

lib.print_string_array.argtypes =  [POINTER(c_char_p), c_int]
lib.FreeStringArray.argtypes = [POINTER(c_char_p), c_int]

lib.print_int_array.argtypes =  [POINTER(c_int), c_int]
lib.FreeIntArray.argtypes = [POINTER(c_int)]

lib.print_float_array.argtypes =  [POINTER(c_float), c_int]
lib.FreeFloatArray.argtypes =  [POINTER(c_float)]

lib.return_string.argtypes = [c_char_p]
lib.return_string.restype = c_char_p

lib.FreeCString.argtypes = [c_char_p]

lib.print_string.argtypes = [c_char_p]

## ========== Array-based functions ==========

lib.FreeStringArray.argtypes = [POINTER(c_char_p), c_int]
lib.free_string_array_result.argtypes = [POINTER(_CStringArrayResult)]
lib.return_string_array.argtypes = [POINTER(c_char_p), c_int] 
lib.return_string_array.restype = POINTER(_CStringArrayResult)

lib.return_int_array.argtypes = [POINTER(c_int), c_int]
lib.return_int_array.restype = POINTER(_CIntArrayResult)
lib.free_int_array_result.argtypes = [POINTER(_CIntArrayResult)]

lib.return_float_array.argtypes = [POINTER(c_float), c_int]
lib.return_float_array.restype = POINTER(_CFloatArrayResult)
lib.free_float_array_result.argtypes = [POINTER(_CFloatArrayResult)]

# ========== Nice Typehints/Type Aliases ==========
CIntArray = Array[c_int]
CFloatArray = Array[c_float]
CStringArray = Array[c_char_p]

# ========== Python types to C ============
def prepare_string(data: str | bytes) -> c_char_p:
    """Takes in a string and returns a C-compatible string
    
    Notes
    -----
    - Does not prune null terminators (\\0 characters)

    Parameters
    ----------
    data : str | bytes
        The string to prepare

    Returns
    -------
    c_char_p
        The resulting pointer to the string
    """
    if not data:
        return c_char_p(bytes())
    if type(data) == str:
        return c_char_p(data.encode())
    return c_char_p(bytes(data))

def prepare_string_array(data:list[str|bytes]) -> tuple[CStringArray, int]:
    """Takes in a string list, and converts it to a C-compatible array

    Parameters
    ----------
    data : list[str | bytes]
        The list to convert

    Returns
    -------
    Array[c_char_p], int
        The resulting array, and the number of items
        
    Notes
    -----
    - Because the data is allocated in python, python will free the memory afterwords
    - Does not prune null terminators (\\0 characters)

    Examples
    --------
    
    lib = cdll.LoadLibrary("path/to/library.dll") # Load Library

    # Function that takes in string array, and number of items, then prints them in C
    lib.print_string_array.argtypes =  [POINTER(c_char_p), c_int]

    # Prep data using function
    data = ["Hello", "World", "!"]
    c_array, number_of_items = prepare_string_array(data)

    # Use data in C
    lib.print_string_array(c_array, number_of_items)
    
    """
    # Encode items to bytes
    data = [
            c_char_p(item.encode())
        if type(item) == str
        else
            c_char_p(bytes(item))
        for item in data
    ] 
    number_of_items = len(data)
    array_type = c_char_p * number_of_items # Create a C array of char* (aka **char)
    c_array = array_type(*data)
    return c_array, number_of_items

def prepare_int_array(data:list[int]) -> tuple[CIntArray, int]:
    """Takes in an int list, and converts it to a C-compatible array

    Parameters
    ----------
    data : list[int]
        The list of integers to convert to an array

    Returns
    -------
    Array[c_int], int
        The resulting array, and the number of items
    
    Notes
    -----
    - Because the data is allocated in python, python will free the memory afterwords
        
    Examples
    --------
    
    lib = cdll.LoadLibrary("path/to/library.dll") # Load Library

    # Function that takes in int array, and number of items, then prints them in C
    lib.print_int_array.argtypes =  [POINTER(c_int), c_int]

    # Prep data using function
    data = [1,2,3,4]
    c_array, number_of_items = prepare_int_array(data)

    # Use data in C
    lib.print_int_array(c_array, number_of_items)
    
    """
    data = [c_int(item) for item in data] # Force an error if wrong type
    number_of_items = len(data)
    array_type = c_int * number_of_items # Create a C array of int*
    c_array = array_type(*data)
    return c_array, number_of_items

def prepare_float_array(data:list[float]) -> tuple[CFloatArray, int]:
    """Takes in an float list, and converts it to a C-compatible array

    Parameters
    ----------
    data : list[float]
        The list of integers to convert to an array

    Returns
    -------
    Array[c_float], int
        The resulting array, and the number of items
    
    Notes
    -----
    - Because the data is allocated in python, python will free the memory afterwords
    - The data is only accurate up to ~4 decimals (i.e. if value is -790.5207366698761 you might get -790.520751953125)
        
    Examples
    --------
    
    lib = cdll.LoadLibrary("path/to/library.dll") # Load Library

    # Function that takes in float array, and number of items, then prints them in C
    lib.print_float_array.argtypes =  [POINTER(c_float), c_int]

    # Prep data using function
    data = [1.0,2.604,3.14159,4.964]
    c_array, number_of_items = prepare_float_array(data)

    # Use data in C
    lib.print_float_array(c_array, number_of_items)
    
    """
    data = [c_float(item) for item in data]  # Force an error if wrong type
    number_of_items = len(data)
    array_type = c_float * number_of_items # Create a C array of float*
    c_array = array_type(*data)
    return c_array, number_of_items

# ========== Convert C types to python ============
def string_to_str(pointer: c_char_p) -> str:
    """Takes in a pointer to a C string and returns a Python string

    Parameters
    ----------
    pointer : c_char_p
        A C-style string pointer returned from Go

    Notes
    -----
    - Assumes the pointer is a valid null-terminated UTF-8 encoded string
    - Does NOT free the pointer automatically, you must call `lib.FreeCString(pointer)` if needed

    Returns
    -------
    str
        The decoded Python string representation of the C string
        
    Examples
    --------
    
    c_str = prepare_string(b"Hello from Python!")
    result: str = string_to_str(c_str)
    lib.FreeCString(c_str)
    
    """
    if pointer:
        return pointer.value.decode("utf-8", errors="replace")
    return ""

def string_array_result_to_list(pointer:_CStringArrayResult) -> list[str]:
    """Takes in a pointer to a string result and returns a list of strings

    Parameters
    ----------
    pointer : _CStringArrayResult
        A pointer to a CString Result

    Notes
    -----
    - free's the original pointer

    Returns
    -------
    list[str]
        The list of strings the pointer pointed to
        
    Examples
    --------
    
    data = [
        random.choice(["Lorem", "ipsum", "dolor", "sit", "amet"]) 
        for _ in range(100)
    ]
    
    c_array, number_of_elements = prepare_string_array(data)
    
    pointer = return_string_array(c_array, number_of_elements)
    
    result:list[str] = string_array_result_to_list(pointer)
    
    """
    try:
        result_data = pointer.contents
        results = []
        for i in range(result_data.numberOfElements):
            results.append(result_data.data[i].decode(errors='replace'))
        return results
    finally:
        lib.free_string_array_result(pointer)

def int_array_result_to_list(pointer: _CIntArrayResult) -> list[int]:
    """Converts C int result struct to a Python list, and frees memory."""
    try:
        result_data = pointer.contents
        return [result_data.data[i] for i in range(result_data.numberOfElements)]
    finally:
        lib.free_int_array_result(pointer)

def float_array_result_to_list(pointer: _CFloatArrayResult) -> list[float]:
    """Converts C float result struct to a Python list, and frees memory."""
    try:
        result_data = pointer.contents
        return [result_data.data[i] for i in range(result_data.numberOfElements)]
    finally:
        lib.free_float_array_result(pointer)

# ========== Debugging Functions ==========

def return_string(text: str | bytes) -> str:
    """Debugging function that shows you the Go representation of a C string and returns the python string version

    Parameters
    ----------
    text : str | bytes
        The text to get the representation of

    Returns
    -------
    str
        The returned string
    """
    c_input = prepare_string(text)
    result = lib.return_string(c_input)

    if not result:
        return ""

    copied_bytes = string_at(result)
    decoded = copied_bytes.decode(errors="replace")

    return decoded

def return_string_array(c_array:CStringArray, number_of_elements:int) ->list[str]:
    """Debugging function that shows you the Go representation of a C array and returns the python list version

    Parameters
    ----------
    c_array : Array[c_char_p]
        The array to print and convert
    number_of_elements : int
        The number of elements in the array

    Notes
    -----
    - DOES NOT FREE INPUT ARRAY
    - This function returns the PYTHON list version, do not reassign input variable or it'll never free (i.e. c_array = return_string_array(c_array, number_of_elements))

    Returns
    -------
    list[str]
        The python string representation of the array
        
    Examples
    --------
    
    data = [
        random.choice(["Lorem", "ipsum", "dolor", "sit", "amet"]) 
        for _ in range(100)
    ]
    
    c_array, number_of_elements = prepare_string_array(data)
    
    result:list[str] = return_string_array(c_array, number_of_elements)
    
    lib.free_string_array_result(c_array, number_of_elements)
    
    """
    pointer = lib.return_string_array(c_array, number_of_elements)

    result_data = pointer.contents
    results = []
    for i in range(result_data.numberOfElements):
        results.append(result_data.data[i].decode(errors='replace'))
    return results

def return_int_array(c_array: CIntArray, number_of_elements: int) -> list[int]:
    """Debugging function that shows you the Go representation of a C int array and returns a Python list

    Notes
    -----
    - DOES NOT FREE INPUT ARRAY
    - Frees input array ONLY on exception
    - Returns the PYTHON list version, do not reassign input variable

    Returns
    -------
    list[int]
    """
    pointer = lib.return_int_array(c_array, number_of_elements)
    try:
        result_data = pointer.contents
        return [result_data.data[i] for i in range(result_data.numberOfElements)]
    except Exception as e:
        print(f"return_int_array(): Ran into error, freeing memory. Error: {e}")
        lib.free_int_array_result(c_array)  # In case you define a similar freeing function for input
        raise e
    finally:
        lib.free_int_array_result(pointer)

def return_float_array(c_array: CFloatArray, number_of_elements: int) -> list[float]:
    """Debugging function that shows you the Go representation of a C float array and returns a Python list

    Notes
    -----
    - DOES NOT FREE INPUT ARRAY ON SUCCESS
    - Frees input array ONLY on exception
    - Returns the PYTHON list version, do not reassign input variable
    - The data is only accurate up to ~4 decimals (i.e. if value is -790.5207366698761 you might get -790.520751953125)

    Returns
    -------
    list[float]
    """
    pointer = lib.return_float_array(c_array, number_of_elements)
    try:
        result_data = pointer.contents
        return [result_data.data[i] for i in range(result_data.numberOfElements)]
    except Exception as e:
        print(f"return_float_array(): Ran into error, freeing memory. Error: {e}")
        lib.free_float_array_result(c_array)  # In case you define a similar freeing function for input
        raise e
    finally:
        lib.free_float_array_result(pointer)

def print_string(text: str | bytes):
    """Prints a string's go representation, useful to look for encoding issues

    Parameters
    ----------
    text : str | bytes
        The data you want to see the go representation of
    """
    c_input = prepare_string(text)
    lib.print_string(c_input)

def print_string_array(data:list[str|bytes]):
    """Prints a string array's go representation, useful to look for encoding issues

    Notes
    -----
    - Does not free because everything is allocated in python, so GC will take care of it

    Parameters
    ----------
    data : list[str | bytes]
        The data you want to see the go representation of
    """
    c_array, number_of_items = prepare_string_array(data)

    lib.print_string_array(c_array, number_of_items)

def print_int_array(data:list[int]):
    """Prints a int array's go representation, useful to look for rounding/conversion issues

    Notes
    -----
    - Does not free because everything is allocated in python, so GC will take care of it

    Parameters
    ----------
    data : list[int]
        The data you want to see the go representation of
    """
    c_array, number_of_items = prepare_int_array(data)

    lib.print_int_array(c_array, number_of_items)

def print_float_array(data:list[float]):
    """Prints a float array's go representation, useful to look for rounding/conversion issues

    Notes
    -----
    - Does not free because everything is allocated in python, so GC will take care of it

    Parameters
    ----------
    data : list[float]
        The data you want to see the go representation of
    """
    c_array, number_of_items = prepare_float_array(data)
    lib.print_float_array(c_array, number_of_items)

# ========== Free Functions ==========
def free_c_string(ptr: c_char_p):
    """Frees a single C string returned from Go (allocated via C.CString)."""
    lib.FreeCString(ptr)

def free_string_array(ptr: CStringArray, count: int):
    """Frees an array of C strings returned from Go."""
    lib.FreeStringArray(ptr, count)

def free_int_array(ptr: CIntArray):
    """Frees a C int array returned from Go."""
    lib.FreeIntArray(ptr)
    
def free_float_array(ptr: CFloatArray):
    """Frees a C float array returned from Go."""
    lib.FreeFloatArray(ptr)

def free_string_array_result(ptr: _CStringArrayResult):
    """Frees a StringArrayResult (including the array of strings and struct itself)."""
    lib.free_string_array_result(ptr)

def free_int_array_result(ptr: _CIntArrayResult):
    """Frees an IntArrayResult (including the array and the struct itself)."""
    lib.free_int_array_result(ptr)

def free_float_array_result(ptr: _CFloatArrayResult):
    """Frees a FloatArrayResult (including the array and the struct itself)."""
    lib.free_float_array_result(ptr)

__init__.py

"""A package to help with building Go-python libraries

Helper Functions
----------------
- get_library(dll_path:str,source_path:str="", compile:bool=False) -> CDLL: Get's the DLL specified, will compile if not found and flag is specified

Converting to ctypes
--------------------
- prepare_string(data: str | bytes) -> c_char_p: Takes in a string and returns a C-compatible string
- prepare_string_array(data:list[str|bytes]) -> tuple[Array[c_char_p], int]: Takes in a string list, and converts it to a C-compatible array
- prepare_int_array(data:list[int]) -> tuple[Array[c_int], int]: Takes in a int list, and converts it to a C-compatible array
- prepare_float_array(data:list[float]) -> tuple[Array[c_float], int]: Takes in a float list, and converts it to a C-compatible array

Converting from ctypes
----------------------
- string_to_str(pointer: c_char_p) -> str: Takes in a pointer to a C string and returns a Python string
- string_array_result_to_list(pointer:_CStringArrayResult) -> list[str]: 
- int_array_result_to_list(pointer: _CIntArrayResult) -> list[int]: 
- float_array_result_to_list(pointer: _CFloatArrayResult) -> list[float]: 

Debugging Functions
-------------------
- return_string(text: str | bytes) -> str: Debugging function that shows you the Go representation of a C string and returns the python string version
- return_string_array(c_array:CStringArray, number_of_elements:int) ->list[str]: Debugging function that shows you the Go representation of a C array and returns the python list version (does not free)
- return_int_array(c_array: CIntArray, number_of_elements: int) -> list[int]: Debugging function that shows you the Go representation of a C int array and returns a Python list
- return_float_array(c_array: CFloatArray, number_of_elements: int) -> list[float]: Debugging function that shows you the Go representation of a C float array and returns a Python list
- print_string(text: str | bytes): Prints a string's go representation, useful to look for encoding issues
- print_string_array(data:list[str|bytes]): Prints a string array's go representation, useful to look for encoding issues
- print_int_array(data:list[int]): Prints a int array's go representation, useful to look for rounding/conversion issues
- print_float_array(data:list[float]): Prints a float array's go representation, useful to look for rounding/conversion issues

Freeing Functions
-----------------
- free_c_string(ptr: c_char_p): Frees a single C string returned from Go (allocated via C.CString).
- free_string_array(ptr: CStringArray, count: int): Frees an array of C strings returned from Go.
- free_int_array(ptr: CIntArray): Frees a C int array returned from Go.
- free_float_array(ptr: CFloatArray): Frees a C float array returned from Go.
- free_string_array_result(ptr: _CStringArrayResult): Frees a StringArrayResult (including the array of strings and struct itself).
- free_int_array_result(ptr: _CIntArrayResult): Frees an IntArrayResult (including the array and the struct itself).
- free_float_array_result(ptr: _CFloatArrayResult): Frees a FloatArrayResult (including the array and the struct itself).
"""
import os
from platform import platform

# Exported functions
from .lib import (
    get_library,
    prepare_string,
    prepare_string_array,
    prepare_int_array,
    prepare_float_array,
    string_array_result_to_list,
    int_array_result_to_list,
    float_array_result_to_list,
    return_string,
    return_string_array,
    return_int_array,
    return_float_array,
    print_string,
    print_string_array,
    print_int_array,
    print_float_array,
    free_c_string,
    free_string_array,
    free_int_array,
    free_float_array,
    free_string_array_result,
    free_int_array_result,
    free_float_array_result,
)

# Check if library exists, and if it doesn't compile it
dll_source_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "lib.go")
if platform().lower().startswith("windows"):
    dll_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),"lib.dll")
    get_library(dll_file, dll_source_file, True)
else:
    dll_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),"lib.so")
    get_library(dll_file, dll_source_file, True)

The lib.free_sites() is being called in the loop:

for i in range(count):
  print(f"Storing site {i}/{count}")
  site_ptr = pointer[i]
  data = site_ptr
  try:
      results.append(cls(
          url=data.url.decode(errors="replace"),
          domain=data.domain.decode(errors="replace"),
          server=data.server.decode(errors="replace"),
          protocol=data.protocol.decode(errors="replace"),
          contentType=data.contentType.decode(errors="replace"),
          body=data.body.decode(errors="replace"),
          port=data.port
      ))
  except AttributeError:
      continue # No data
  finally:
      cls.free_sites(pointer,count )

here is the fixed code:

try:
  for i in range(count):
      print(f"Storing site {i}/{count}")
      site_ptr = pointer[i]
      data = site_ptr
      try:
          results.append(cls(
              url=data.url.decode(errors="replace"),
              domain=data.domain.decode(errors="replace"),
              server=data.server.decode(errors="replace"),
              protocol=data.protocol.decode(errors="replace"),
              contentType=data.contentType.decode(errors="replace"),
              body=data.body.decode(errors="replace"),
              port=data.port
          ))
      except AttributeError:
          continue # No data for one of the values
finally:
  cls.free_sites(pointer,count )