$"""$

You are employed by a new company called "AlgoZon," with the task of enhancing the package

delivery process. The company aims to identify whether a driver has taken a circular route during

package deliveries. Your responsibility is to determine if$,$ at any point in the trip, the driver returned

to a location they had previously visited.

The monitoring system currently in use at AlgoZon tracks routes by drivers as a Linked List, where

each node has an ID $($integer$)$ and a timestamp $($in Unix format$).$

Each node represents a package pickup zone where a driver gets packages.

To check for inefficiency, AlgoZon has assigned you the task of writing a function that will detect

whether a driver has returned to the same pickup zone. Additionally, you must also audit whether

the linked list of destinations is in chronological order; in order words, we want to detect an error

if a driver reaches a destination before the previous one in the linked list.

Write a function that takes in the first node in the monitoring linked list and returns the total time

for the cycle, or null if there isn$$t one. The function should throw an InvalidRouteError if any

destination in the linked list is reached before its predecessor $($even after a cycle$).$

The code for a node class and InvalidRouteError class is provided below.

Code Author:

$"""$

class PickupSnapshotNode:

def $\_\_$init$\_\_($self$,$ location$\_$id: int, timestamp: int, next$\_$node: 'PickupSnapshotNode'$)$:

self.id $=$ location$\_$id

self.timestamp $=$ timestamp

self.next $=$ next$\_$node

def get$\_$id$($self$)$:

return self.id

def get$\_$timestamp$($self$)$:

return self.timestamp

def get$\_$next$($self$)$:

return self.next

def set$\_$next$($self$,$ node: 'PickupSnapshotNode'$)$:

self.next $=$ node

class InvalidRouteError$($Exception$)$:

def $\_\_$init$\_\_($self$)$:

super$().\_\_$init$\_\_()$

def detect$\_$cyclic$\_$route$($start: PickupSnapshotNode$)$:

pass

class TestingBase:

def print$\_$test$\_$result$($self$,$ test$\_$name, result$)$:

color $="\backslash 033[92$m$"$ if result else $"\backslash 033[91$m$"$

reset $="\backslash 033[0$m$"$

print$($f$"\{$color$\}[\{$result$\}]\{$test$\_$name$\}\{$reset$\}")$

def test$\_$answer$($self$,$ test$\_$name, expected, result$)$:

if result $==$ expected:

self.print$\_$test$\_$result$($test$\_$name, True$)$

else:

self.print$\_$test$\_$result$($test$\_$name, False$)$

print$($f$"$Expected: $\{$expected$\}$

Got: $\{$result$\}")$

# Unit Testing Class

class TestRideSnapshotNode$($TestingBase$)$:

def run$\_$unit$\_$tests$($self$)$:

self.test$\_$detect$\_$cyclic$\_$ride$()$

self.test$\_$detect$\_$cyclic$\_$ride$\_$no$\_$cycle$()$

self.test$\_$back$\_$in$\_$time$\_1()$

self.test$\_$back$\_$in$\_$time$\_2()$

self.test$\_$detects$\_$cyclic$\_$ride$\_2()$

self.test$\_$detects$\_$non$\_$cyclic$\_$ride$\_2()$

self.test$\_$back$\_$in$\_$time$\_$after$\_$cycle$()$

def test$\_$detect$\_$cyclic$\_$ride$($self$)$:

# Create nodes for a cyclic ride

node$4=$ PickupSnapshotNode$(12345,1685288860,$ None$)$

node$3=$ PickupSnapshotNode$(21341,1685288560,$ node$4)$

node$2=$ PickupSnapshotNode$(12345,1685288260,$ node$3)$

node$1=$ PickupSnapshotNode$(32144,1685287960,$ node$2)$

# Call the detect$\_$cyclic$\_$ride function

result $=$ detect$\_$cyclic$\_$route$($node$1)$

# Cycle is node $2->$ node $3->$ node $4$

expected$\_$answer $=1685288860-1685288260$

self.test$\_$answer$("$test$\_$detect$\_$cyclic$\_$ride$\_$with$\_$cycle", expected$\_$answer, result$)$

def test$\_$detect$\_$cyclic$\_$ride$\_$no$\_$cycle$($self$)$:

# Create nodes for a non$-$cyclic ride

node$4=$ PickupSnapshotNode$(12345,1685288860,$ None$)$

node$3=$ PickupSnapshotNode$(21341,1685288560,$ node$4)$

node$2=$ PickupSnapshotNode$(32144,1685288260,$ node$3)$

node$1=$ PickupSnapshotNode$(12237,1685287960,$ node$2)$

# Call the detect$\_$cyclic$\_$ride function

result $=$ detect$\_$cyclic$\_$route$($node$1)$

# Assert that no cycle is detected $($result should be None or False$)$

self.test$\_$answer$("$test$\_$detect$\_$cyclic$\_$ride$\_$no$\_$cycle", None, result$)$

def test$\_$back$\_$in$\_$time$\_1($self$)$:

node$1=$ PickupSnapshotNode$(1,1,$ None$)$

node$2=$ PickupSnapshotNode$(2,2,$ None$)$

node$3=$ PickupSnapshotNode$(3,3,$ None$)$

node$4=$ PickupSnapshotNode$(4,4,$ None$)$

node$5=$ PickupSnapshotNode$(5,3,$ None$)$

node$1.$set$\_$next$($node$2)$

node$2.$set$\_$next$($node$3)$

node$3.$set$\_$next$($node$4)$

node$4.$set$\_$next$($node$5)$

try:

result $=$ detect$\_$cyclic$\_$route$($node$1)$

self.print$\_$test$\_$result$("$testBackInTime$1",$ False$)$

print$("$Expected to get error but got: $",$ result$)$

except InvalidRouteError:

self.print$\_$test$\_$result$("$testBackInTime$1",$ True$)$

def test$\_$back$\_$in$\_$time$\_2($self$)$:

node$1=$ PickupSnapshotNode$(1,1,$ None$)$

node$2=$ PickupSnapshotNode$(2,2,$ None$)$

node$3=$ PickupSnapshotNode$(3,3,$ None$)$

node$4=$ PickupSnapshotNode$(4,4,$ None$)$

node$5=$ PickupSnapshotNode$(5,5,$ None$)$

node$1.$set$\_$next$($node$2)$