In pyton :

Overload the necessary operator$($s$)($that is $\_\_$gt$\_\_)$ so that instead of

having to write

$2.$ if t$1.$after$($t$2)$: $...$

we can use the more convenient

if t$1>$ t$2$: $...$

$3.$ Rewrite all other relational operators in step $3,4(==,<,<=,>,>=,!=).$

$4.$ Create some test cases to test out the above changes Consider

specifically the case where the number of seconds to add to the time is

negative. Fix up increment, $>$ so that it handles this case if it does not do

so already. $($You may assume that you will never subtract more

seconds than are in the time object.$)$

$5.$ Given that physical time cannot be negative, or must time always

move in the forward direction. Adjust your code above in step $1$ to $6$ so

that it will never go into negative time.

I have created the code and implemented the question from $2$ till $3$ however I am not able to do $4$ and $5.$ The professor stated that "negative time protection" was missing from my code. Can anyone please check my code and help me understand how to add negative time protection in the code. Thank you

My code:

class MyTime:

def $\_\_$init$\_\_($self$,$ hrs$=0,$ mins$=0,$ secs$=0)$:

$"""$ Create a MyTime object initialized to hrs$,$ mins, secs $"""$

totalsecs $=$ hrs$*3600+$ mins$*60+$ secs

self.hours $=$ totalsecs $//3600$ # Split in h$,$ m$,$ s

leftoversecs $=$ totalsecs $\%3600$

self.minutes $=$ leftoversecs $//60$

self.seconds $=$ leftoversecs $\%60$

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

return $"\{0\}$:$\{1\}$:$\{2\}".$format$($self$.$hours, self.minutes, self.seconds$)$

def $\_\_$add$\_\_($self$,$ other$)$:

return MyTime$(0,0,$ self.to$\_$seconds$()+$ other.to$\_$seconds$())$

def $\_\_$sub$\_\_($self$,$ other$)$:

return MyTime$(0,0,$ self.to$\_$seconds$()-$ other.to$\_$seconds$())$

def $\_\_$lt$\_\_($self$,$ other$)$:

return self.to$\_$seconds$()<$ other.to$\_$seconds$()$

def $\_\_$le$\_\_($self$,$ other$)$:

return self.to$\_$seconds$()<=$ other.to$\_$seconds$()$

def $\_\_$gt$\_\_($self$,$ other$)$:

return self.to$\_$seconds$()>$ other.to$\_$seconds$()$

def $\_\_$ge$\_\_($self$,$ other$)$:

return self.to$\_$seconds$()>=$ other.to$\_$seconds$()$

def $\_\_$eq$\_\_($self$,$ other$)$:

return self.to$\_$seconds$()==$ other.to$\_$seconds$()$

def $\_\_$ne$\_\_($self$,$ other$)$:

return self.to$\_$seconds$()!=$ other.to$\_$seconds$()$

def increment$($self$,$ secs$)$:

self.seconds $+=$ secs

while self.seconds $>=60$:

self.seconds $-=60$

self.minutes $+=1$

while self.minutes $>=60$:

self.minutes $-=60$

self.hours $+=1$

while self.seconds $<0$:

self.seconds $+=60$

self.minutes $-=1$

while self.minutes $<0$:

self.minutes $+=60$

self.hours $-=1$

while self.hours $<0$:

self.hours $+=24$

def to$\_$seconds$($self$)$:

$"""$ Return the number of seconds represented by this instance"""

return self.hours $*3600+$ self.minutes $*60+$ self.seconds

def after$($self$,$ time$2)$:

$"""$ Return True if I am strictly greater than time$2"""$

return self.to$\_$seconds$()>$ time$2.$to$\_$seconds$()$

def add$\_$time$2($t$1,$ t$2)$:

secs $=$ t$1.$to$\_$seconds$()+$ t$2.$to$\_$seconds$()$

return MyTime$(0,0,$ secs$)$

def add$\_$time$($t$1,$ t$2)$:

h $=$ t$1.$hours $+$ t$2.$hours

m $=$ t$1.$minutes $+$ t$2.$minutes

s $=$ t$1.$seconds $+$ t$2.$seconds

sum$\_$t $=$ MyTime$(0,0,$ secs$)$

return sum$\_$t

my main code:

from MyTime import MyTime

X $=$ MyTime$(1,2,3)$

Y $=$ MyTime$(2,3,4)$

Z $=$ X $-$ Y

print$($Z$)$

print$()$

# Test Relational Operators

print$("$X $<$ Y:$",$ X $<$ Y$)$

print$("$X $>$ Y:$",$ X $>$ Y$)$

print$("$X $<=$ Z:$",$ X $<=$ Z$)$

print$("$Y $>=$ Z:$",$ Y $>=$ Z$)$

print$("$X $==$ Y:$",$ X $==$ Y$)$

print$("$X $!=$ Y:$",$ X $!=$ Y$)$

print$()$

# Test increment

def increment$($t$,$ secs$)$:

t$.$seconds $+=$ secs

t$.$increment$()$

Z$.$increment$(800)$

print$($Z$)$

Z$.$increment$(-800)$

print$($Z$)$