vortexpy 4.2.0__tar.gz → 4.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.2.0
+Version: 4.2.1
 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.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.2.0"
+version = "4.2.1"
 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.2.1}/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.2.1}/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.2.1}/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.2.1}/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.2.1}/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.2.1}/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.2.1}/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.2.1/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.2.1}/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.2.1/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.2.1}/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}"
             )
 
 

{vortexpy-4.2.0 → vortexpy-4.2.1}/vortex/TuplePolymorphicTupleTypeFieldArgTest.py

@@ -98,5 +98,8 @@ class PolymorphicTupleTypeFieldArgTest(unittest.TestCase):
             any(err.field_path == "concreteType" for err in result.errors)
         )
         self.assertTrue(
-            any(err.message.startswith("At concreteType:") for err in result.errors)
+            any(
+                err.message.startswith("At concreteType:")
+                for err in result.errors
+            )
         )

{vortexpy-4.2.0 → vortexpy-4.2.1}/vortex/TupleRestful.py

@@ -14,6 +14,7 @@ Implementation module; public interface remains on vortex.Tuple.
 
 from __future__ import annotations
 
+import enum
 import re
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -160,12 +161,16 @@ class TupleRestfulConverter:
                 return [convert(item) for item in value]
 
             if isinstance(value, dict):
-                return {convert(key): convert(item) for key, item in value.items()}
+                return {
+                    convert(key): convert(item) for key, item in value.items()
+                }
 
             from .Tuple import Tuple
 
             if isinstance(value, Tuple):
-                return cls.tupleToRestfulJsonDict(value, includeNones, includeFalse)
+                return cls.tupleToRestfulJsonDict(
+                    value, includeNones, includeFalse
+                )
 
             if isinstance(value, WKBElement):
                 return convertFromWkbElement(value)
@@ -202,7 +207,10 @@ class TupleRestfulConverter:
                 else prefix
             )
             detail = validationError.message
-            if validationError.message.startswith("At ") and ": " in validationError.message:
+            if (
+                validationError.message.startswith("At ")
+                and ": " in validationError.message
+            ):
                 detail = validationError.message.split(": ", 1)[1]
             prefixed.append(
                 cls._makeError(field_path, detail, validationError.exc_type)
@@ -256,6 +264,73 @@ class TupleRestfulConverter:
 
         return True
 
+    @classmethod
+    def _isStrEnumType(cls, enumType: type[enum.Enum]) -> bool:
+        return issubclass(enumType, str) and issubclass(enumType, enum.Enum)
+
+    @classmethod
+    def _isIntEnumType(cls, enumType: type[enum.Enum]) -> bool:
+        return (
+            issubclass(enumType, int)
+            and issubclass(enumType, enum.Enum)
+            and not issubclass(enumType, bool)
+        )
+
+    @classmethod
+    def _enumTypeFromHint(cls, typeHint: Any) -> type[enum.Enum] | None:
+        if isinstance(typeHint, type) and issubclass(typeHint, enum.Enum):
+            if cls._isStrEnumType(typeHint) or cls._isIntEnumType(typeHint):
+                return typeHint
+            return None
+
+        for unionArg in get_args(typeHint):
+            if unionArg is type(None):
+                continue
+            if isinstance(unionArg, type) and issubclass(unionArg, enum.Enum):
+                if cls._isStrEnumType(unionArg) or cls._isIntEnumType(unionArg):
+                    return unionArg
+
+        return None
+
+    @classmethod
+    def _tryCoerceEnumValue(
+        cls,
+        field_path: str,
+        fieldName: str,
+        TupleClass: Type[Tuple],
+        typeHint: Any,
+        value: Any,
+    ) -> tuple[Any, TupleValidationError | None]:
+        if value is None:
+            return value, None
+
+        enumType = cls._enumTypeFromHint(typeHint)
+        if enumType is None:
+            return value, None
+
+        if isinstance(value, enumType):
+            return value, None
+
+        try:
+            if cls._isStrEnumType(enumType) and isinstance(value, str):
+                return enumType(value), None
+
+            if (
+                cls._isIntEnumType(enumType)
+                and isinstance(value, int)
+                and not isinstance(value, bool)
+            ):
+                return enumType(value), None
+        except ValueError:
+            return value, cls._makeError(
+                field_path,
+                f"parsing {TupleClass}, field {fieldName}"
+                f" is not a valid {enumType.__name__} value, got {value!r}",
+                ValueError,
+            )
+
+        return value, None
+
     @classmethod
     def _nestedTupleTypeFromHint(cls, typeHint: Any) -> Any | None:
         """Return nested tuple class for a field hint, including ``X | None`` unions."""
@@ -334,8 +409,12 @@ class TupleRestfulConverter:
     ) -> _ConvertResult:
         errors: list[TupleValidationError] = []
         listItemTypeHint = get_args(typeHint)[0]
-        listItemExtraHint = get_args(extraTypeHint)[0] if extraTypeHint else None
-        listItemTypeValidator = cls._getFieldValidatorFromExtraHint(listItemExtraHint)
+        listItemExtraHint = (
+            get_args(extraTypeHint)[0] if extraTypeHint else None
+        )
+        listItemTypeValidator = cls._getFieldValidatorFromExtraHint(
+            listItemExtraHint
+        )
         data: list[Any] = []
 
         if hasattr(listItemTypeHint, "__tupleType__"):
@@ -356,10 +435,22 @@ class TupleRestfulConverter:
                     item, listItemTypeHint
                 )
                 data.append(child.tuple_)
-                errors.extend(cls._prefixValidationErrors(child.errors, item_path))
+                errors.extend(
+                    cls._prefixValidationErrors(child.errors, item_path)
+                )
         else:
             for index, item in enumerate(value):
                 item_path = f"{field_path}[{index}]"
+                item, enumError = cls._tryCoerceEnumValue(
+                    item_path,
+                    fieldName,
+                    TupleClass,
+                    listItemTypeHint,
+                    item,
+                )
+                if enumError:
+                    errors.append(enumError)
+                    continue
                 itemError = cls._checkType(
                     TupleClass,
                     item_path,
@@ -440,7 +531,9 @@ class TupleRestfulConverter:
         typeHint: Any,
     ) -> _ConvertResult:
         if hasattr(typeHint, "__tupleType__"):
-            child = cls.restfulJsonDictToTupleWithValidationResult(value, typeHint)
+            child = cls.restfulJsonDictToTupleWithValidationResult(
+                value, typeHint
+            )
             return _ConvertResult(
                 child.tuple_,
                 cls._prefixValidationErrors(child.errors, field_path),
@@ -517,6 +610,13 @@ class TupleRestfulConverter:
         ):
             value = datetime.strptime(value, ISO8601)
 
+        value, enumError = cls._tryCoerceEnumValue(
+            field_path, fieldName, TupleClass, typeHint, value
+        )
+        if enumError:
+            errors.append(enumError)
+            return _ConvertResult(_UNSET, errors)
+
         typeError = cls._checkType(
             TupleClass, field_path, fieldName, typeHint, value, validator
         )
@@ -587,7 +687,9 @@ class TupleRestfulConverter:
     def restfulJsonDictToTupleWithValidation(
         cls, jsonDict: dict[str, Any], TupleClass: Type[Tuple]
     ) -> Tuple:
-        result = cls.restfulJsonDictToTupleWithValidationResult(jsonDict, TupleClass)
+        result = cls.restfulJsonDictToTupleWithValidationResult(
+            jsonDict, TupleClass
+        )
         if result.errors:
             firstValidationError = result.errors[0]
             raise firstValidationError.exc_type(firstValidationError.message)