vortexpy 4.2.0__tar.gz → 4.3.0__tar.gz

{vortexpy-4.2.0/vortexpy.egg-info → vortexpy-4.3.0}/PKG-INFO

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

{vortexpy-4.2.0 → vortexpy-4.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.2.0"
+version = "4.3.0"
 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-4.2.0 → vortexpy-4.3.0}/vortex/DeferUtil.py

@@ -8,7 +8,6 @@
 
 import inspect
 import logging
-import time
 from collections.abc import Callable
 from typing import ParamSpec, TypeVar
 
@@ -210,27 +209,7 @@ def deferToThreadWrapWithLogger(
                     "Deferring to a thread can only be done from the main thread"
                 )
 
-            def timedFuncToRun(*runArgs: _P.args, **runKwargs: _P.kwargs) -> _R:
-                startMonotonic = time.monotonic()
-                try:
-                    return funcToWrap(*runArgs, **runKwargs)
-                finally:
-                    durationMs = (time.monotonic() - startMonotonic) * 1000.0
-                    from vortex.twisted_runtime_metrics import (
-                        STACK_CAPTURE_THRESHOLD_MS,
-                        TwistedRuntimeMetrics,
-                    )
-
-                    methodFrame = None
-                    if durationMs >= STACK_CAPTURE_THRESHOLD_MS:
-                        methodFrame = TwistedRuntimeMetrics._captureWorkerThreadFrame()
-                    TwistedRuntimeMetrics._collector()._recordThreadedCall(
-                        funcToWrap.__qualname__,
-                        durationMs,
-                        methodFrame,
-                    )
-
-            d: Deferred[_R] = deferToThread(timedFuncToRun, *args, **kwargs)
+            d: Deferred[_R] = deferToThread(funcToWrap, *args, **kwargs)
             d.addCallback(checkForInlineCallbackYield)
             d.addErrback(vortexLogFailure, loggerArg, consumeError=consumeError)
             return d
@@ -246,9 +225,13 @@ def isMainThread():
 
 def noMainThread():
     if isMainThread():
-        raise Exception("Blocking operations shouldn't occur in the reactors thread.")
+        raise Exception(
+            "Blocking operations shouldn't occur in the reactors thread."
+        )
 
 
 def yesMainThread():
     if not isMainThread():
-        raise Exception("Async operations must occur in the reactors main thread.")
+        raise Exception(
+            "Async operations must occur in the reactors main thread."
+        )

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/Jsonable.py

@@ -107,9 +107,11 @@ class Jsonable(object):
         try:
             valueType = V_NULL if value is None else toRapuiType(value)
         except KeyError as e:
+            unsupportedType = e.args[0] if e.args else value.__class__
             raise KeyError(
-                "%s field name is %s, type is %s", e, name, value.__class__
-            )
+                "%r field name is %r, type is %r"
+                % (unsupportedType, name, value.__class__)
+            ) from e
 
         # Payloads and Tuples
         if self.__isRawJsonableField(name):

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/PayloadEndpoint.py

@@ -22,7 +22,9 @@ from vortex.VortexAccessControlContextABC import (
     NO_AUTH_ACCESS_CONTROL_CONTEXT,
     VortexAccessControlContextABC,
 )
-from vortex.VortexEndpointPermission import EndpointPermissionsType as PermissionsType
+from vortex.VortexEndpointPermission import (
+    EndpointPermissionsType as PermissionsType,
+)
 from vortex.VortexSession import (
     _callableLabel,
     checkAccessControlContextSignature,
@@ -69,6 +71,7 @@ class PayloadEndpoint:
         acceptOnlyFromVortex: Optional[Union[str, tuple]] = None,
         ignoreFromVortex: Optional[Union[str, tuple]] = None,
         requiredPermissions: Optional[PermissionsType] = None,
+        logProcessException: bool = True,
     ) -> None:
         """
         :param filt: The filter to match against payloads
@@ -80,8 +83,13 @@ class PayloadEndpoint:
             the caller's session must hold.  Pass an empty frozenset to
             explicitly declare "no permissions required".  Omitting the
             parameter (``None``) emits a deprecation warning.
+        :param logProcessException: When True, handler exceptions log at ERROR.
+            When False, the same events log at DEBUG with neutral wording.
         """
-        self._requiredPermissions: Optional[PermissionsType] = requiredPermissions
+        self._requiredPermissions: Optional[PermissionsType] = (
+            requiredPermissions
+        )
+        self._logProcessException = logProcessException
 
         if requiredPermissions is None:
             logger.warning(self._NO_PERMISSIONS_WARNING, filt)
@@ -89,9 +97,11 @@ class PayloadEndpoint:
         callableDesc = (
             f"PayloadEndpoint filt={filt} callback={_callableLabel(callable_)}"
         )
-        self._callableAcceptsAccessControlContext = checkAccessControlContextSignature(
-            callable_,
-            callableDescription=callableDesc,
+        self._callableAcceptsAccessControlContext = (
+            checkAccessControlContextSignature(
+                callable_,
+                callableDescription=callableDesc,
+            )
         )
         checkNoHttpSessionInSignature(callable_, callableDesc)
 
@@ -168,7 +178,10 @@ class PayloadEndpoint:
             return False
 
         # Filter for the backend vortexes.
-        if self._acceptOnlyFromVortex and vortexName not in self._acceptOnlyFromVortex:
+        if (
+            self._acceptOnlyFromVortex
+            and vortexName not in self._acceptOnlyFromVortex
+        ):
             return False
 
         def removeUnhashable(filt):
@@ -212,7 +225,9 @@ class PayloadEndpoint:
         if not self.check(payloadEnvelope, vortexName):
             return
 
-        if self.PERMITTER and not self.PERMITTER.check(payloadEnvelope, vortexSession):
+        if self.PERMITTER and not self.PERMITTER.check(
+            payloadEnvelope, vortexSession
+        ):
             logger.debug("Permission failed for %s", payloadEnvelope.filt)
             return
 
@@ -250,7 +265,10 @@ class PayloadEndpoint:
         accessControlContext = NO_AUTH_ACCESS_CONTROL_CONTEXT
         if self._callableAcceptsAccessControlContext and auth and vortexSession:
             raw_ctx = yield maybeDeferred(
-                auth.getAccessControlContext, vortexSession, vortexName, vortexUuid
+                auth.getAccessControlContext,
+                vortexSession,
+                vortexName,
+                vortexUuid,
             )
             if not isinstance(raw_ctx, VortexAccessControlContextABC):
                 logger.error(

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/PayloadEndpointTest.py

@@ -143,9 +143,7 @@ class PayloadEndpointPyTest(unittest.TestCase):
 
         def subScope():
             inst = PayloadEndpointPyTestAssignPayload(self)
-            PayloadEndpoint(
-                filt, inst.process, requiredPermissions=frozenset()
-            )
+            PayloadEndpoint(filt, inst.process, requiredPermissions=frozenset())
 
         self._processEnvelope(payload)
         yield self._flushReactor()

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/PayloadEnvelope.py

@@ -57,9 +57,9 @@ class PayloadEnvelope(Jsonable):
     ) -> None:
         Jsonable.__init__(self)
         """Constructor"""
-        assert not (
-            data and encodedPayload
-        ), "You can not pass encodedData and encodedPayload"
+        assert not (data and encodedPayload), (
+            "You can not pass encodedData and encodedPayload"
+        )
 
         self.filt: Dict = {} if filt is None else filt
         self.data: Union[Any, str, None] = data if data else encodedPayload
@@ -75,18 +75,18 @@ class PayloadEnvelope(Jsonable):
     @property
     def encodedPayload(self) -> Optional[str]:
         # self.data could be from VortexJS/Typescript where we allow `str` data
-        assert self.data is None or isinstance(
-            self.data, str
-        ), "Encoded payload is not None or a string"
+        assert self.data is None or isinstance(self.data, str), (
+            "Encoded payload is not None or a string"
+        )
         return self.data
 
     @encodedPayload.setter
     def encodedPayload(self, val: Optional[str]):
         # This value should only be set from users of VortexPy and
         # Payload.toEncodedPayload so we only allow str or None
-        assert val is None or isinstance(
-            val, str
-        ), "Encoded payload is not None or a string"
+        assert val is None or isinstance(val, str), (
+            "Encoded payload is not None or a string"
+        )
         self.data = val
 
     def isEmpty(self):

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/PayloadIO.py

@@ -115,8 +115,15 @@ class PayloadIO(object):
             except Exception as e:
                 logger.exception(e)
 
-            vortexLogFailure(failure, logger)
-            logger.error(payloadEnvelope.filt)
+            if endpoint._logProcessException:
+                vortexLogFailure(failure, logger)
+                logger.error(payloadEnvelope.filt)
+            else:
+                logger.debug(
+                    "Payload handler response for filt=%s: %s",
+                    payloadEnvelope.filt,
+                    failure.getErrorMessage(),
+                )
 
         def callback(value, blocking=False):
             # A blocking call taking more than 100ms is BAD

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/PayloadResponse.py

@@ -67,7 +67,7 @@ class PayloadResponse(Deferred):
         destVortexUuid: Optional[str] = None,
         timeout: Optional[float] = None,
         resultCheck=True,
-        logTimeoutError=True,
+        logTimeoutException=True,
     ) -> None:
         """Constructor
 
@@ -81,6 +81,8 @@ class PayloadResponse(Deferred):
         :param timeout The timeout to wait for a response
         :param resultCheck Should the response payload.result be checked, if it fails
                     it errback will be called.
+        :param logTimeoutException: When True, payload timeouts log at ERROR.
+                    When False, timeouts log at DEBUG with neutral wording.
         """
         Deferred.__init__(self)
 
@@ -88,7 +90,7 @@ class PayloadResponse(Deferred):
             timeout = self.TIMEOUT
 
         self._resultCheck = resultCheck
-        self._logTimeoutError = logTimeoutError
+        self._logTimeoutException = logTimeoutException
 
         # uuid4 can have collisions
         self._messageId = str(uuid4()) + str(PayloadResponse.__SEQ)
@@ -142,8 +144,10 @@ class PayloadResponse(Deferred):
             self._endpoint.shutdown()
             self._endpoint = None
 
-        if self._logTimeoutError:
+        if self._logTimeoutException:
             logger.error("Timed out for payload %s", self._filt)
+        else:
+            logger.debug("Payload response timed out for %s", self._filt)
         self._status = self.TIMED_OUT
         return failure
 

vortexpy-4.3.0/vortex/PayloadResponse_test.py

@@ -0,0 +1,42 @@
+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()

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/SerialiseUtil.py

@@ -7,6 +7,7 @@
 # Support : contact@flyingion.com
 
 import decimal
+import enum
 import logging
 from base64 import b64encode, b64decode
 from collections import defaultdict
@@ -267,6 +268,13 @@ def toRapuiType(value):
     if isinstance(value, PayloadEnvelope):
         return T_RAPUI_PAYLOAD_ENVELOPE
 
+    if isinstance(value, enum.Enum):
+        if isinstance(value, str):
+            return T_STR
+        if isinstance(value, int):
+            return T_INT
+        raise KeyError(value.__class__)
+
     valueClass = value.__class__
 
     return TYPE_MAP_PY_TO_RAPUI[valueClass]

vortexpy-4.3.0/vortex/SerialiseUtil_test.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+import json
+from enum import Enum, IntEnum, StrEnum
+
+from twisted.trial import unittest
+
+from vortex.SerialiseUtil import T_INT, T_STR, fromStr, toRapuiType, toStr
+from vortex.TupleSelector import TupleSelector
+
+
+class SampleStrEnumE(StrEnum):
+    CrewDatum = "crew-datum"
+    ViewJobDetail = "view-job-detail-datum"
+
+
+class SampleIntEnumE(IntEnum):
+    One = 1
+    Two = 2
+
+
+class SamplePlainEnumE(Enum):
+    Alpha = "alpha"
+
+
+class SerialiseUtilTest(unittest.TestCase):
+    def testToRapuiTypeStrEnumMember(self) -> None:
+        self.assertEqual(toRapuiType(SampleStrEnumE.CrewDatum), T_STR)
+        self.assertEqual(
+            toRapuiType(SampleStrEnumE.ViewJobDetail),
+            T_STR,
+        )
+
+    def testToRapuiTypeIntEnumMember(self) -> None:
+        self.assertEqual(toRapuiType(SampleIntEnumE.One), T_INT)
+        self.assertEqual(toRapuiType(SampleIntEnumE.Two), T_INT)
+
+    def testToRapuiTypePlainEnumMemberRaises(self) -> None:
+        with self.assertRaises(KeyError) as errorInfo:
+            toRapuiType(SamplePlainEnumE.Alpha)
+
+        self.assertEqual(errorInfo.exception.args, (SamplePlainEnumE,))
+
+    def testToStrStrEnumMember(self) -> None:
+        self.assertEqual(toStr(SampleStrEnumE.CrewDatum), "crew-datum")
+
+    def testFromStrRoundTripStrEnumWireValue(self) -> None:
+        wireValue = toStr(SampleStrEnumE.CrewDatum)
+        self.assertEqual(fromStr(wireValue, T_STR), "crew-datum")
+
+    def testTupleSelectorSerialisesStrEnumSelectorValues(self) -> None:
+        selector = TupleSelector(
+            "peek_core_datum.DatumMappingTuple",
+            dict(
+                sourcePlugin="peek_plugin_switching_viewer",
+                datumPendingKey=SampleStrEnumE.CrewDatum,
+            ),
+        )
+        jsonStr = selector.toJsonStr()
+        parsed = json.loads(jsonStr)
+        self.assertEqual(
+            parsed["selector"]["datumPendingKey"],
+            "crew-datum",
+        )
+        self.assertEqual(parsed["selector"]["sourcePlugin"], "peek_plugin_switching_viewer")
+
+    def testTupleSelectorStrEnumRoundTrip(self) -> None:
+        original = TupleSelector(
+            "peek_core_datum.DatumMappingTuple",
+            dict(
+                sourcePlugin="peek_plugin_switching_viewer",
+                datumPendingKey=SampleStrEnumE.ViewJobDetail,
+            ),
+        )
+        restored = TupleSelector.fromJsonStr(original.toJsonStr())
+        self.assertEqual(restored.name, original.name)
+        self.assertEqual(
+            restored.selector["datumPendingKey"],
+            "view-job-detail-datum",
+        )
+        self.assertIsInstance(restored.selector["datumPendingKey"], str)
+
+    def testTupleSelectorSerialisesIntEnumSelectorValues(self) -> None:
+        selector = TupleSelector(
+            "test.ExampleTuple",
+            dict(priority=SampleIntEnumE.Two),
+        )
+        jsonStr = selector.toJsonStr()
+        parsed = json.loads(jsonStr)
+        self.assertEqual(
+            parsed["selector"]["priority"],
+            {"_fd": 2, "_ft": "int"},
+        )
+
+    def testTupleSelectorIntEnumRoundTrip(self) -> None:
+        original = TupleSelector(
+            "test.ExampleTuple",
+            dict(priority=SampleIntEnumE.One),
+        )
+        restored = TupleSelector.fromJsonStr(original.toJsonStr())
+        self.assertEqual(restored.selector["priority"], 1)
+        self.assertIsInstance(restored.selector["priority"], int)
+
+    def testTupleSelectorUnsupportedEnumFieldNameInError(self) -> None:
+        selector = TupleSelector(
+            "DashboardDataTimespanUpdatedTupleSelector",
+            dict(objectType=SamplePlainEnumE.Alpha),
+        )
+
+        with self.assertRaises(KeyError) as errorInfo:
+            selector.toJsonStr()
+
+        self.assertEqual(
+            errorInfo.exception.args[0],
+            "%r field name is %r, type is %r"
+            % (SamplePlainEnumE, "objectType", SamplePlainEnumE),
+        )

{vortexpy-4.2.0 → vortexpy-4.3.0}/vortex/Tuple.py

@@ -354,13 +354,12 @@ class IntTupleFieldValidator(TupleFieldValidatorABC):
     def validate(self, fieldName: str, value):
         if self._low is not None and value < self._low:
             raise ValueError(
-                f"Field {fieldName}," f" Value {value} is less than {self._low}"
+                f"Field {fieldName}, Value {value} is less than {self._low}"
             )
 
         if self._high is not None and self._high < value:
             raise ValueError(
-                f"Field {fieldName},"
-                f" Value {value} is greater than {self._high}"
+                f"Field {fieldName}, Value {value} is greater than {self._high}"
             )
 
 
@@ -384,6 +383,13 @@ class _TupleToPlainJsonMixin:
             self, includeNones, includeFalse
         )
 
+    def tupleToBsonJsonDict(self, includeNones=True, includeFalse=True):
+        from vortex.TupleBson import TupleBsonConverter
+
+        return TupleBsonConverter.tupleToBsonJsonDict(
+            self, includeNones, includeFalse
+        )
+
     def __tupleToJsonDict(
         self, includeNones=True, includeFalse=True, useShortNames=True
     ):
@@ -507,6 +513,31 @@ class _TupleToPlainJsonMixin:
             jsonDict, TupleClass
         )
 
+    @staticmethod
+    def bsonJsonDictToTupleWithValidation(
+        jsonDict: dict, TupleClass: Type["Tuple"]
+    ) -> "Tuple":
+        """BSON document dict to Tuple with validation.
+
+        This method uses the typings on the fields in a tuple to validate the
+        types of data.
+        """
+        from vortex.TupleBson import TupleBsonConverter
+
+        return TupleBsonConverter.bsonJsonDictToTupleWithValidation(
+            jsonDict, TupleClass
+        )
+
+    @staticmethod
+    def bsonJsonDictToTupleWithValidationResult(
+        jsonDict: dict, TupleClass: Type["Tuple"]
+    ) -> "TupleValidationResult":
+        from vortex.TupleBson import TupleBsonConverter
+
+        return TupleBsonConverter.bsonJsonDictToTupleWithValidationResult(
+            jsonDict, TupleClass
+        )
+
 
 class Tuple(Jsonable, _TupleToPlainJsonMixin, _TupleToSqlaJsonMixin):
     """Tuple