vortexpy 6.2.2__tar.gz → 6.2.4__tar.gz

{vortexpy-6.2.2 → vortexpy-6.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 6.2.2
+Version: 6.2.4
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-6.2.2 → vortexpy-6.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "6.2.2"
+version = "6.2.4"
 license = {text = "MIT"}
 authors = [{name = "Flying Ion Pty Ltd", email = "contact@flyingion.com"}]
 description = "Flying Ion's observable, routable, data serialisation and transport code."

{vortexpy-6.2.2 → vortexpy-6.2.4}/vortex/PayloadResponse.py

@@ -16,6 +16,8 @@ from uuid import uuid4
 import pytz
 from twisted.internet import reactor
 from twisted.internet.defer import Deferred
+from twisted.internet.defer import TimeoutError
+from twisted.internet.interfaces import IDelayedCall
 from twisted.python.failure import Failure
 
 from vortex.PayloadEndpoint import PayloadEndpoint
@@ -68,6 +70,7 @@ class PayloadResponse(Deferred):
         timeout: Optional[float] = None,
         resultCheck=True,
         logTimeoutException=True,
+        retries: Optional[int] = None,
     ) -> None:
         """Constructor
 
@@ -83,9 +86,16 @@ class PayloadResponse(Deferred):
                     it errback will be called.
         :param logTimeoutException: When True, payload timeouts log at ERROR.
                     When False, timeouts log at DEBUG with neutral wording.
+        :param retries: The number of times to resend the payload envelope
+                    when the response times out; None sends once with no
+                    retries. Requires destVortexName or destVortexUuid.
         """
         Deferred.__init__(self)
 
+        assert retries is None or (destVortexName or destVortexUuid), (
+            "retries requires destVortexName or destVortexUuid to resend"
+        )
+
         if not timeout:
             timeout = self.TIMEOUT
 
@@ -99,6 +109,11 @@ class PayloadResponse(Deferred):
         payloadEnvelope.filt[self.MESSAGE_ID_KEY] = self._messageId
         self._filt = copy(payloadEnvelope.filt)
         self._destVortexName = destVortexName
+        self._destVortexUuid = destVortexUuid
+        self._payloadEnvelope = payloadEnvelope
+        self._timeout = timeout
+        self._retries: Optional[int] = retries
+        self._timeoutDelayedCall: Optional[IDelayedCall] = None
 
         self._status = self.PROCESSING
         self._date = datetime.now(pytz.utc)
@@ -107,23 +122,49 @@ class PayloadResponse(Deferred):
             self._filt, self._process, requiredPermissions=frozenset()
         )
 
-        if destVortexName or destVortexUuid:
-            d: Deferred = payloadEnvelope.toVortexMsgDefer()
-            d.addCallback(
-                VortexFactory.sendVortexMsg,
-                destVortexName=destVortexName,
-                destVortexUuid=destVortexUuid,
-            )
-            d.addErrback(self.errback)
+        self._sendVortexMsg()
 
         try:
             raise Exception()
         except:
             self._stack = sys.exc_info()[2]
 
-        # noinspection PyTypeChecker
-        self.addTimeout(timeout, reactor)
-        self.addErrback(self._timedOut)
+        if retries is None:
+            # noinspection PyTypeChecker
+            self.addTimeout(timeout, reactor)
+            self.addErrback(self._timedOut)
+        else:
+            self._armTimeout()
+
+    def _sendVortexMsg(self) -> None:
+        if not (self._destVortexName or self._destVortexUuid):
+            return
+
+        d: Deferred = self._payloadEnvelope.toVortexMsgDefer()
+        d.addCallback(
+            VortexFactory.sendVortexMsg,
+            destVortexName=self._destVortexName,
+            destVortexUuid=self._destVortexUuid,
+        )
+        d.addErrback(self.errback)
+
+    def _armTimeout(self) -> None:
+        self._timeoutDelayedCall = reactor.callLater(  # type: ignore[attr-defined]  # pyright: ignore[reportAttributeAccessIssue]
+            self._timeout, self._onTimeout
+        )
+
+    def _onTimeout(self) -> None:
+        self._timeoutDelayedCall = None
+
+        if self._retries:
+            self._retries -= 1
+            self._sendVortexMsg()
+            self._armTimeout()
+            return
+
+        failure = Failure(TimeoutError("timed out"))
+        self._timedOut(failure)
+        self.errback(failure)
 
     @classmethod
     def isResponsePayloadEnvelope(cls, payloadEnvelope: PayloadEnvelope):
@@ -162,6 +203,12 @@ class PayloadResponse(Deferred):
             self._endpoint.shutdown()
             self._endpoint = None
 
+        if self._timeoutDelayedCall is not None:
+            # zope Interface methods omit self, which static analysis cannot bind
+            if self._timeoutDelayedCall.active():  # pyright: ignore[reportAttributeAccessIssue]
+                self._timeoutDelayedCall.cancel()  # pyright: ignore[reportAttributeAccessIssue]
+            self._timeoutDelayedCall = None
+
         if self._destVortexName and vortexName != self._destVortexName:
             logger.debug(
                 "Received response from a vortex other than the dest vortex, "
@@ -175,14 +222,10 @@ class PayloadResponse(Deferred):
             logger.error("Received response after timeout for %s" % self._filt)
             return
 
-        if self._resultCheck and not payloadEnvelope.result in (None, True):
+        if self._resultCheck and payloadEnvelope.result not in (None, True):
             self._status = self.FAILED
             self.errback(
-                Failure(
-                    Exception(payloadEnvelope.result).with_traceback(
-                        self._stack
-                    )
-                )
+                Failure(Exception(payloadEnvelope.result).with_traceback(self._stack))
             )
 
         else:

vortexpy-6.2.4/vortex/PayloadResponse_test.py

@@ -0,0 +1,161 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from twisted.internet.defer import TimeoutError
+from twisted.internet.defer import succeed
+from twisted.python.failure import Failure
+
+from vortex.PayloadEnvelope import PayloadEnvelope
+from vortex.PayloadResponse import PayloadResponse
+
+
+class _FakeDelayedCall:
+    def __init__(self, callback) -> None:
+        self.callback = callback
+        self.cancelled = False
+
+    def active(self) -> bool:
+        return not self.cancelled
+
+    def cancel(self) -> None:
+        self.cancelled = True
+
+    def fire(self) -> None:
+        self.callback()
+
+
+class _FakeReactor:
+    def __init__(self) -> None:
+        self.delayedCalls: list[_FakeDelayedCall] = []
+
+    def callLater(self, _seconds: float, callback) -> _FakeDelayedCall:
+        call = _FakeDelayedCall(callback)
+        self.delayedCalls.append(call)
+        return call
+
+
+class PayloadResponseLoggingTest(unittest.TestCase):
+    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
+    @patch("vortex.PayloadResponse.logger")
+    def testTimeoutLogsDebugWhenLogTimeoutExceptionFalse(
+        self, mockLogger: MagicMock, _mockSend: MagicMock
+    ) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            timeout=30.0,
+            logTimeoutException=False,
+        )
+        pr._timedOut(Failure(TimeoutError("timed out")))
+        mockLogger.error.assert_not_called()
+        mockLogger.debug.assert_called_once()
+
+    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
+    @patch("vortex.PayloadResponse.logger")
+    def testTimeoutLogsErrorWhenLogTimeoutExceptionTrue(
+        self, mockLogger: MagicMock, _mockSend: MagicMock
+    ) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            timeout=30.0,
+            logTimeoutException=True,
+        )
+        pr._timedOut(Failure(TimeoutError("timed out")))
+        mockLogger.debug.assert_not_called()
+        mockLogger.error.assert_called_once()
+
+
+class PayloadResponseRetryTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.fakeReactor = _FakeReactor()
+        patch("vortex.PayloadResponse.reactor", self.fakeReactor).start()
+        self.mockSend: MagicMock = patch(
+            "vortex.PayloadResponse.VortexFactory.sendVortexMsg"
+        ).start()
+        patch(
+            "vortex.PayloadEnvelope.PayloadEnvelope.toVortexMsgDefer",
+            return_value=succeed(b"{}"),
+        ).start()
+        self.addCleanup(patch.stopall)
+
+    def testTimeoutResendsPayloadAndSucceedsOnLateResponse(self) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            destVortexName="destVortex",
+            timeout=30.0,
+            retries=1,
+        )
+
+        self.assertEqual(self.mockSend.call_count, 1)
+        self.assertEqual(len(self.fakeReactor.delayedCalls), 1)
+
+        # First attempt times out, the payload is resent and re-armed
+        self.fakeReactor.delayedCalls[0].fire()
+
+        self.assertEqual(self.mockSend.call_count, 2)
+        self.assertEqual(len(self.fakeReactor.delayedCalls), 2)
+        self.assertEqual(pr.status, PayloadResponse.PROCESSING)
+
+        # The resent payload receives a response
+        results = []
+        pr.addCallback(results.append)
+        response = PayloadEnvelope(filt={"key": "example"})
+        pr._process(response, "vortexUuid", "destVortex")
+
+        self.assertEqual(pr.status, PayloadResponse.SUCCESS)
+        self.assertEqual(results, [response])
+        self.assertTrue(self.fakeReactor.delayedCalls[1].cancelled)
+
+    def testExhaustedRetriesErrbackWithTimedOut(self) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            destVortexName="destVortex",
+            timeout=30.0,
+            retries=1,
+        )
+
+        failures = []
+        pr.addErrback(failures.append)
+
+        self.fakeReactor.delayedCalls[0].fire()
+        self.assertEqual(self.mockSend.call_count, 2)
+        self.assertEqual(pr.status, PayloadResponse.PROCESSING)
+
+        self.fakeReactor.delayedCalls[1].fire()
+
+        self.assertEqual(self.mockSend.call_count, 2)
+        self.assertEqual(pr.status, PayloadResponse.TIMED_OUT)
+        self.assertEqual(len(failures), 1)
+        self.assertIsInstance(failures[0].value, TimeoutError)
+
+    def testRetriesRequiresDestinationVortex(self) -> None:
+        with self.assertRaises(AssertionError):
+            PayloadResponse(
+                PayloadEnvelope(filt={"key": "example"}),
+                timeout=30.0,
+                retries=1,
+            )
+
+    def testDefaultTimeoutPathDoesNotResend(self) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            destVortexName="destVortex",
+            timeout=30.0,
+        )
+
+        failures = []
+        pr.addErrback(failures.append)
+
+        self.assertEqual(self.mockSend.call_count, 1)
+        self.assertEqual(len(self.fakeReactor.delayedCalls), 1)
+
+        # addTimeout cancels the deferred, which errbacks with TimeoutError
+        self.fakeReactor.delayedCalls[0].fire()
+
+        self.assertEqual(self.mockSend.call_count, 1)
+        self.assertEqual(pr.status, PayloadResponse.TIMED_OUT)
+        self.assertEqual(len(failures), 1)
+        self.assertIsInstance(failures[0].value, TimeoutError)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vortexpy-6.2.2 → vortexpy-6.2.4}/vortex/TupleDocumentConverter.py

@@ -421,8 +421,12 @@ class TupleDocumentConverterBase:
                     return cls._makeError(field_path, str(exc), ValueError)
             return None
 
-        if isinstance(value, list) and get_origin(typeHint) is list:
-            return None
+        if isinstance(value, list):
+            if get_origin(typeHint) is list:
+                return None
+            for unionArg in get_args(typeHint):
+                if get_origin(unionArg) is list:
+                    return None
 
         if isinstance(value, dict):
             if get_origin(typeHint) is dict:

{vortexpy-6.2.2 → vortexpy-6.2.4}/vortex/__init__.py

@@ -6,4 +6,4 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
-__version__ = '6.2.2'
+__version__ = '6.2.4'

{vortexpy-6.2.2 → vortexpy-6.2.4}/vortexpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 6.2.2
+Version: 6.2.4
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-6.2.2 → vortexpy-6.2.4}/vortexpy.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-LICENSE
 README.md
 pyproject.toml
 example/TwistedDeferredTimeout.py

vortexpy-6.2.2/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2016-2026 Flying Ion Pty Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-

vortexpy-6.2.2/vortex/PayloadResponse_test.py

@@ -1,42 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-from twisted.internet.defer import TimeoutError
-from twisted.python.failure import Failure
-
-from vortex.PayloadEnvelope import PayloadEnvelope
-from vortex.PayloadResponse import PayloadResponse
-
-
-class PayloadResponseLoggingTest(unittest.TestCase):
-    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
-    @patch("vortex.PayloadResponse.logger")
-    def testTimeoutLogsDebugWhenLogTimeoutExceptionFalse(
-        self, mockLogger: MagicMock, _mockSend: MagicMock
-    ) -> None:
-        pr = PayloadResponse(
-            PayloadEnvelope(filt={"key": "example"}),
-            timeout=30.0,
-            logTimeoutException=False,
-        )
-        pr._timedOut(Failure(TimeoutError("timed out")))
-        mockLogger.error.assert_not_called()
-        mockLogger.debug.assert_called_once()
-
-    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
-    @patch("vortex.PayloadResponse.logger")
-    def testTimeoutLogsErrorWhenLogTimeoutExceptionTrue(
-        self, mockLogger: MagicMock, _mockSend: MagicMock
-    ) -> None:
-        pr = PayloadResponse(
-            PayloadEnvelope(filt={"key": "example"}),
-            timeout=30.0,
-            logTimeoutException=True,
-        )
-        pr._timedOut(Failure(TimeoutError("timed out")))
-        mockLogger.debug.assert_not_called()
-        mockLogger.error.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()