Why isn't my code working $?$

from dynamic$\_$array import $*$

class MinHeapException$($Exception$)$:

$"""$

Custom exception to be used by MinHeap class

DO NOT CHANGE THIS CLASS IN ANY WAY

$"""$

pass

class MinHeap:

def $\_\_$init$\_\_($self$,$ start$\_$heap$=$None$)$:

$"""$

Initialize a new MinHeap

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

self.$\_$heap $=$ DynamicArray$()$

# populate MinHeap with initial values $($if provided$)$

# before using this feature, implement add$()$ method

if start$\_$heap:

for node in start$\_$heap:

self.add$($node$)$

def $\_\_$str$\_\_($self$)->$ str:

$"""$

Return MinHeap content in human$-$readable form

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

heap$\_$data $=[$self$.\_$heap$[$i$]$ for i in range$($self$.\_$heap.length$())]$

return "HEAP $"+$ str$($heap$\_$data$)$

def add$($self$,$ node: object$)->$ None:

$"""$

This method adds a new object to the MinHeap while maintaining heap property

$"""$

self.$\_$heap.append$($node$)$

self.$\_$bubble$\_$up$($self$.\_$heap.length$()-1)$

def $\_$bubble$\_$up$($self$,$ index: int$)->$ None:

$"""$

Helper function that restores the heap property by moving the element at index upward.

$"""$

while index $>0$:

parent $=($index $-1)//2$

if self.$\_$heap$[$index$]>=$ self.$\_$heap$[$parent$]$:

break

self.$\_$heap$[$index$],$ self.$\_$heap$[$parent$]=$ self.$\_$heap$[$parent$],$ self.$\_$heap$[$index$]$

index $=$ parent

def is$\_$empty$($self$)->$ bool:

$"""$

This method returns True if the heap is empty; otherwise, it returns False.

$"""$

if self.$\_$heap.length$()==0$:

return True

return False

def get$\_$min$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

if self.is$\_$empty$()$:

raise MinHeapException$("$Heap is empty"$)$

return self.$\_$heap$[0]$

def remove$\_$min$($self$)->$ object:

$"""$

Removes and returns the smallest element $($root$)$ of the heap.

$"""$

if self.is$\_$empty$()$:

raise MinHeapException$("$Heap is empty"$)$

min$\_$value $=$ self.$\_$heap.get$\_$at$\_$index$(0)$

# Step $2$: Replace the root with the last element and shrink the heap

last$\_$index $=$ self.$\_$heap.length$()-1$

self.$\_$heap.set$\_$at$\_$index$(0,$ self.$\_$heap.get$\_$at$\_$index$($last$\_$index$))$

self.$\_$heap.pop$()$ # Remove the last element

# Step $3$: Restore the heap property by percolating down from the root

if not self.is$\_$empty$()$:

self.$\_$percolate$\_$down$(0)$

return min$\_$value

def build$\_$heap$($self$,$ da: DynamicArray$)->$ None:

$"""$

TODO: Write this implementation

$"""$

self.$\_$heap $=$ DynamicArray$()$

for i in range$($da$.$length$())$:

self.$\_$heap.append$($da$.$get$\_$at$\_$index$($i$))$

# Step $2$: Perform heapify$-$down from the last non$-$leaf node to the root

start$\_$index $=($self$.\_$heap.length$()-2)//2$ # Index of the last non$-$leaf node

for index in range$($start$\_$index, $-1,-1)$:

self.$\_$percolate$\_$down$($self$.\_$heap, index$)$

def size$($self$)->$ int:

$"""$

TODO: Write this implementation

$"""$

return self.$\_$heap.length$()$

def clear$($self$)->$ None:

$"""$

TODO: Write this implementation

$"""$

self.$\_$heap $=$ DynamicArray$()$ # Reinitialize the heap as an empty DynamicArray

self.$\_$size $=0$

def heapsort$($da: DynamicArray$)->$ None:

$"""$

TODO: Write this implementation

$"""$

n $=$ da$.$length$()$

# Build the heap from the last non$-$leaf node

for i in range$($n $//2-1,-1,-1)$:

$\_$percolate$\_$down$($da$,$ i$)$

# Step $2$: Extract elements one by one and place them at the end

for i in range$($n $-1,0,-1)$:

# Swap the root $($maximum$)$ with the last element

da$.$set$\_$at$\_$index$($i$,$ da$.$get$\_$at$\_$index$(0))$ # Swap root and last element

da$.$set$\_$at$\_$index$(0,$ da$.$get$\_$at$\_$index$($i$))$ # Move maximum to end

# Percolate down the root to restore the heap property

$\_$percolate$\_$down$($da$,0)$

# It's highly recommended that you implement the following optional #

# helper function for percolating elements down the MinHeap. You can call #

# this from inside the MinHeap class. You may edit the function definition. #

def $\_$percolate$\_$down$($da: DynamicArray, parent: int$)->$ None:

$"""$

This is a helper method that moves the element at the given parent index

down the heap to restore the MinHeap property.

$"""$

while True:

left$\_$child $=2*$ parent $+1$

right$\_$child $=2*$ parent $+2$

smallest $=$ parent

# Compare parent with left child

if left$\_$child $<$ da$.$length$()$ and da$.$get$\_$at$\_$index$($left$\_$child$)<$ da$.$get$\_$at$\_$index$($smallest$)$:

smallest $=$ left$\_$child

# Compare smallest so far with right child

if right$\_$child $<$ da$.$length$()$ and da$.$get$\_$at$\_$index$($right$\_$child$)<$ da$.$get$\_$at$\_$index$($smallest$)$:

smallest $=$ right$\_$child

# If the parent is already smaller than both children, we're done

if smallest $==$ parent:

break

# Swap parent with the smallest child and continue

da$.$set$\_$at$\_$index$($parent$,$ da$.$get$\_$at$\_$index$($smallest$))$

da$.$set$\_$at$\_$index$($smallest$,$ da$.$get$\_$at$\_$index$($parent$))$

parent $=$ smallest