Please Explain how I can make task $5$ calculate d$=$private key using the signature

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

# function to find signature

def task$\_4($self$,$ from$\_$user$\_$id: str$,$ to$\_$user$\_$id: str$,$ amount: int, d: int, e: int, n: int$)->$ int:

# TODO: Implement this method for Task $4$

# Build the transaction string

# The transaction string should be in the format of "from$\_$user$\_$id:to$\_$user$\_$id:amount"

trans $=$ from$\_$user$\_$id $+\text{'}$:$\text{'}+$ to$\_$user$\_$id $+\text{'}$:$\text{'}+$ str$($amount$)$

# Hash the transaction string

# This provides a fixed$-$size string, which simplifies further processing and ensures that the

# data hasn't been altered without detection.

trans$\_$hash $=$ hashlib.sha$256($trans$.$encode$(\text{'}$utf$-8\text{'}))$

print$("$Transaction hash:

$",$ trans$\_$hash$)$

# You may find this line helpful for getting the integer value of the transaction hash

trans$\_$hash$\_$as$\_$int $=$ int.from$\_$bytes$($trans$\_$hash.digest$(),$ sys$.$byteorder$)$

# Encrypt$/$Sign the transaction hash

signature $=$ pow$($trans$\_$hash$\_$as$\_$int, d$,$ n$)$

print$("$Signed hash:

$",$ signature$)$

# Create the signature $($the number $11$ is simply a placeholder$)$

return signature

# function to find factors

def task$\_5($self$,$ n$\_$str: str$,$ e$\_$str: str$)->$ str:

n $=$ int$($n$\_$str$,16)$

e $=$ int$($e$\_$str$,16)$

# Step $1$

p$,$ q $=$ self.get$\_$factors$($n$)$

# Step $2$

d $=$ self.get$\_$private$\_$key$\_$from$\_$p$\_$q$\_$e$($p$,$ q$,$ e$)$

return hex$($d$).$rstrip$(\text{'}$L$\text{'})$

def task$\_6($self$,$ given$\_$public$\_$key$\_$n: int, given$\_$public$\_$key$\_$e: int, public$\_$key$\_$list: list$)->$ int:

# TODO: Implement this method for Task $6$

d $=0$

return d

def get$\_$private$\_$key$\_$from$\_$p$\_$q$\_$e$($self$,$ p: int, q: int, e: int$)$:

# Calculate phi$($n$)$

phi$\_$n $=($p $-1)*($q $-1)$

# Calculate the modular inverse of e modulo phi$($n$)$

try:

d $=$ pow$($e$,-1,$ phi$\_$n$)$

except ValueError:

# Handle the case where the modular inverse does not exist

d $=0$

return d

def get$\_$factors$($self$,$ n: int$)$:

# TODO: Implement this method for Task $5,$ Step $1$

# n $=$ p $*$ q

# data structure to store all the factors

factors $=[]$

limit $=$ math.sqrt$($n$)$ #this is why alg will have exponential running time complexity

for p in range$(2,$ math.floor$($limit $+1))$:

if n $\%$ p $==0$:

#factors.append$([$i$,$ n$/$i$])$

q $=$ n $//$ p

if self.is$\_$prime$($p$)$ and self.is$\_$prime$($q$)$:

return p$,$ q

# Create a list to store the factor pairs

# Check to see which are relative primes

p $=0$

q $=0$

# Return $0,0$ if no factors are found

return p$,$ q

def is$\_$prime$($self$,$ n$,$ k$=10)$:

# we just care about positive integers

if n $<=1$:

return False

# Fermat's primality test is probabilistic: the more k iterations we make

# the higher the probability that the given number is not composite $($so a prime$)$

for $\_$ in range$($k$)$: # dont wanna use iteration counter in python we use underscore

# generate a random number $[2,$N$-1]$

a $=$ random.randint$(2,$ n$)-1$ # a is random integer in range $2->($n$-1)$

# if a$^$n$-1\%$n $!=1$ : then n is not a prime

# if pow$($a$,$ n$-1,$ n$)!=1$:

if pow$($a$,$ n$,$ n$)!=$ a:

return False # then we know the given number is not a prime

# after k iterations we can come to the conclusion that n is a prime

return True