Include initial and remaining time in deadline string representation

Add initial timeout and remaining time when converting a deadline
to an string.
Also, simplify deadline state adding a pointer to
the timeout that was used to create it.

Author: unaiur

maxcube/commander.py

@@ -45,7 +45,7 @@ def get_unsolicited_messages(self) -> List[Message]:
         return result
 
     def update(self) -> List[Message]:
-        deadline = UPDATE_TIMEOUT.deadline()
+        deadline = Deadline(UPDATE_TIMEOUT)
         if self.__is_connected():
             try:
                 response = self.__call(L_MSG, deadline)
@@ -60,7 +60,7 @@ def update(self) -> List[Message]:
         return self.get_unsolicited_messages()
 
     def send_radio_msg(self, hex_radio_msg: str) -> bool:
-        deadline = SEND_RADIO_MSG_TIMEOUT.deadline()
+        deadline = Deadline(SEND_RADIO_MSG_TIMEOUT)
         request = Message(
             "s", base64.b64encode(bytearray.fromhex(hex_radio_msg)).decode("utf-8")
         )

maxcube/deadline.py

@@ -8,35 +8,32 @@ class Timeout:
     name: str
     duration: float
 
-    def deadline(self):
-        return Deadline(self.name, time() + self.duration)
-
 
 class Deadline:
-    def __init__(self, name: str, deadline: float, *, parent=None):
-        self.__name = name
-        self.__deadline = deadline
+    def __init__(self, timeout: Timeout, *, parent=None):
+        if parent is None:
+            self.__deadline = time() + timeout.duration
+        else:
+            self.__deadline = min(time() + timeout.duration, parent.__deadline)
+        self.__timeout = timeout
         self.__parent = parent
 
+    def name(self) -> str:
+        return f"{self.__timeout.name}[{self.remaining():.3g}/{self.__timeout.duration:.3g}]"
+
     def fullname(self) -> str:
-        if not self.__parent:
-            return self.__name
-        return self.__parent.fullname() + ":" + self.__name
+        if self.__parent is None:
+            return self.name()
+        return self.__parent.fullname() + ":" + self.name()
 
     def remaining(self, *, lower_bound: float = 0, upper_bound: float = inf) -> float:
         return min(max(lower_bound, self.__deadline - time()), upper_bound)
 
     def is_expired(self) -> bool:
         return self.remaining() <= 0
 
-    def subdeadline(self, name, deadline: float) -> "Deadline":
-        return Deadline(name, min(self.__deadline, deadline), parent=self)
-
     def subtimeout(self, timeout: Timeout) -> "Deadline":
-        return self.subdeadline(timeout.name, time() + timeout.duration)
+        return Deadline(timeout, parent=self)
 
     def __str__(self) -> str:
-        rem = self.remaining(lower_bound=-inf)
-        if rem < 0:
-            return "Deadline %s expired %.03f seconds ago" % (self.fullname(), -rem)
-        return "Deadline %s will expire in %.03f seconds" % (self.fullname(), rem)
+        return "Deadline " + self.fullname()

tests/test_commander.py

@@ -139,7 +139,7 @@ def testSendRadioMsgClosesConnectionOnErrorAndRetriesIfReusingConnection(
         newConnection.close.assert_not_called()
 
     def __send_radio_msg(self, msg: Message, deadline: Deadline):
-        with patch("maxcube.commander.Timeout.deadline") as deadlineMock:
+        with patch("maxcube.commander.Deadline") as deadlineMock:
             deadlineMock.return_value = deadline
             return self.commander.send_radio_msg(msg)
 
@@ -150,7 +150,7 @@ def testSendRadioMsgShouldNotRetryOnErrorWhenConnectionIsNew(self, ClassMock):
 
         deadline = MagicMock(Deadline)
         deadline.is_expired.side_effect = [False, True]
-        deadline.subtimeout.return_value = TEST_TIMEOUT.deadline()
+        deadline.subtimeout.return_value = Deadline(TEST_TIMEOUT)
 
         self.assertFalse(self.__send_radio_msg(S_CMD_HEX, deadline))
 
@@ -164,7 +164,7 @@ def testSendRadioMsgFailsOnLogicalError(self, ClassMock):
 
         deadline: Deadline = MagicMock(Deadline)
         deadline.is_expired.side_effect = [False, True]
-        deadline.subtimeout.return_value = TEST_TIMEOUT.deadline()
+        deadline.subtimeout.return_value = Deadline(TEST_TIMEOUT)
         self.assertFalse(self.__send_radio_msg(S_CMD_HEX, deadline))
 
         self.connection.send.assert_called_once_with(S_CMD)
@@ -179,7 +179,7 @@ def testSendRadioMsgRetriesOnThrottlingError(self, ClassMock):
         deadline: Deadline = MagicMock(Deadline)
         deadline.is_expired.side_effect = [False, True]
         deadline.remaining.return_value = 0.1
-        deadline.subtimeout.return_value = TEST_TIMEOUT.deadline()
+        deadline.subtimeout.return_value = Deadline(TEST_TIMEOUT)
         self.assertFalse(self.__send_radio_msg(S_CMD_HEX, deadline))
 
         self.connection.send.assert_called_once_with(S_CMD)

tests/test_connection.py

@@ -3,7 +3,7 @@
 from unittest.mock import patch
 
 from maxcube.connection import Connection
-from maxcube.deadline import Timeout
+from maxcube.deadline import Deadline, Timeout
 from maxcube.message import Message
 
 TEST_TIMEOUT = Timeout("test", 1000.0)
@@ -24,7 +24,7 @@ def testReadAMessage(self, socketMock):
         self.socket.recv.return_value = b"A:B\r\n"
 
         self.assertEqual(
-            Message("A", "B"), self.connection.recv(TEST_TIMEOUT.deadline())
+            Message("A", "B"), self.connection.recv(Deadline(TEST_TIMEOUT))
         )
         self.socket.close.assert_not_called()
 
@@ -33,33 +33,31 @@ def testReadPartialLine(self, socketMock):
         self.socket.recv.side_effect = [b"A:", b"B\r\n"]
 
         self.assertEqual(
-            Message("A", "B"), self.connection.recv(TEST_TIMEOUT.deadline())
+            Message("A", "B"), self.connection.recv(Deadline(TEST_TIMEOUT))
         )
 
     def testReadMultipleLines(self, socketMock):
         self.connect(socketMock)
         self.socket.recv.return_value = b"A:B\r\nC\r\n"
 
         self.assertEqual(
-            Message("A", "B"), self.connection.recv(TEST_TIMEOUT.deadline())
+            Message("A", "B"), self.connection.recv(Deadline(TEST_TIMEOUT))
         )
         self.socket.recv.reset_mock()
-        self.assertEqual(
-            Message("C", ""), self.connection.recv(TEST_TIMEOUT.deadline())
-        )
+        self.assertEqual(Message("C", ""), self.connection.recv(Deadline(TEST_TIMEOUT)))
 
     def testReadAtConnectionClosing(self, socketMock):
         self.connect(socketMock)
         self.socket.recv.return_value = b""
 
-        self.assertIsNone(self.connection.recv(TEST_TIMEOUT.deadline()))
+        self.assertIsNone(self.connection.recv(Deadline(TEST_TIMEOUT)))
         self.socket.close.assert_called_once()
 
     def testReadTimeout(self, socketMock):
         self.connect(socketMock)
         self.socket.recv.side_effect = [socket.timeout]
 
-        self.assertIsNone(self.connection.recv(TEST_TIMEOUT.deadline()))
+        self.assertIsNone(self.connection.recv(Deadline(TEST_TIMEOUT)))
         self.socket.close.assert_not_called()
 
     def testSendMessage(self, socketMock):

tests/test_deadline.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
 from unittest.mock import patch
 
-from maxcube.deadline import Timeout
+from maxcube.deadline import Deadline, Timeout
 
 ZERO_TIMEOUT = Timeout("zero", 0)
 ONE_TIMEOUT = Timeout("one", 1)
@@ -14,48 +14,48 @@ class TestDeadline(TestCase):
 
     def testDeadlineLowerBoundForRemainingTime(self, timeMock):
         timeMock.side_effect = [0, 0.4, 0.6]
-        deadline = ONE_TIMEOUT.deadline()
+        deadline = Deadline(ONE_TIMEOUT)
         self.assertAlmostEqual(0.6, deadline.remaining(lower_bound=0.50))
         self.assertAlmostEqual(0.5, deadline.remaining(lower_bound=0.50))
 
     def testDeadlineUpperBoundForRemainingTime(self, timeMock):
         timeMock.side_effect = [0, 0.4, 0.6]
-        deadline = ONE_TIMEOUT.deadline()
+        deadline = Deadline(ONE_TIMEOUT)
         self.assertAlmostEqual(0.5, deadline.remaining(upper_bound=0.50))
         self.assertAlmostEqual(0.4, deadline.remaining(upper_bound=0.50))
 
     def testDeadlineIsExpired(self, timeMock):
         timeMock.side_effect = [0, 0.4, 1.0, 1.000001]
-        deadline = ONE_TIMEOUT.deadline()
+        deadline = Deadline(ONE_TIMEOUT)
         self.assertFalse(deadline.is_expired())
         self.assertTrue(deadline.is_expired())
         self.assertTrue(deadline.is_expired())
 
     def testZeroDeadlineIsAlreadyExpired(self, timeMock):
-        timeMock.side_effect = [0.0, 0.0]
-        deadline = ZERO_TIMEOUT.deadline()
-        self.assertEqual("zero", deadline.fullname())
+        timeMock.return_value = 0.0
+        deadline = Deadline(ZERO_TIMEOUT)
+        self.assertEqual("zero[0/0]", deadline.fullname())
         self.assertTrue(deadline.is_expired())
 
     def testSubtimeoutHandling(self, timeMock):
-        timeMock.side_effect = [0.0, 0.1, 0.2]
-        deadline = ROOT_TIMEOUT.deadline()
+        timeMock.side_effect = [0.0, 0.1, 0.2, 0.2, 0.3]
+        deadline = Deadline(ROOT_TIMEOUT)
         subdeadline = deadline.subtimeout(ONE_TIMEOUT)
-        self.assertEqual("root:one", subdeadline.fullname())
-        self.assertAlmostEqual(0.9, subdeadline.remaining())
+        self.assertEqual("root[9.8/10]:one[0.9/1]", subdeadline.fullname())
+        self.assertAlmostEqual(0.8, subdeadline.remaining())
 
     def testSubtimeoutHandlingWhenLargerThanTimeout(self, timeMock):
         timeMock.side_effect = [0.0, 9.1, 9.2]
-        deadline = ROOT_TIMEOUT.deadline()
+        deadline = Deadline(ROOT_TIMEOUT)
         subdeadline = deadline.subtimeout(ONE_TIMEOUT)
         self.assertAlmostEqual(0.8, subdeadline.remaining())
 
     def testToString(self, timeMock):
         timeMock.side_effect = [0.0, 0.1]
-        deadline = ONE_TIMEOUT.deadline()
-        self.assertEqual("Deadline one will expire in 0.900 seconds", str(deadline))
+        deadline = Deadline(ONE_TIMEOUT)
+        self.assertEqual("Deadline one[0.9/1]", str(deadline))
 
     def testToStringForExpiredDeadline(self, timeMock):
         timeMock.side_effect = [0.0, 1.1]
-        deadline = ONE_TIMEOUT.deadline()
-        self.assertEqual("Deadline one expired 0.100 seconds ago", str(deadline))
+        deadline = Deadline(ONE_TIMEOUT)
+        self.assertEqual("Deadline one[0/1]", str(deadline))