vortexpy 6.2.4__tar.gz → 6.3.0__tar.gz

vortexpy-6.3.0/LICENSE

@@ -0,0 +1,22 @@
+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.4 → vortexpy-6.3.0}/PKG-INFO

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

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

@@ -9,10 +9,9 @@
 import logging
 import traceback
 import typing
+from _collections import defaultdict
 from copy import copy, deepcopy
 from json import JSONEncoder
-from typing import List
-from _collections import defaultdict
 
 logger = logging.getLogger(__name__)
 
@@ -27,15 +26,15 @@ JSONEncoder.item_separator = ","
 JSONEncoder.key_separator = ":"
 
 
-class Jsonable(object):
+class Jsonable:
     """Xmlable
     Inherit from this class if you want to serialise to XML.
     """
 
-    __fieldNames__: List[str] = None
+    __fieldNames__: list[str] = None
     __rapuiSerialiseType__ = T_GENERIC_CLASS
 
-    __rawJonableFields__: List[str] = None
+    __rawJonableFields__: list[str] = None
 
     JSON_CLASS_TYPE = "_ct"
     JSON_CLASS = "_c"
@@ -52,9 +51,7 @@ class Jsonable(object):
         cls.__memoryLoggingEnabled = True
 
     @classmethod
-    def memoryLoggingDump(
-        cls, top=10, over=100
-    ) -> List[typing.Tuple[str, int]]:
+    def memoryLoggingDump(cls, top=10, over=100) -> list[tuple[str, int]]:
         if not Jsonable.__memoryLoggingRefs:
             return []
 
@@ -67,10 +64,10 @@ class Jsonable(object):
         return list(filter(lambda x: x[1] >= over, data))[:top]
 
     def __memLoggingKey(self):
-        if getattr(self, "__rapuiSerialiseType__") == T_RAPUI_TUPLE:
-            key = "Tuple: " + getattr(self, "__tupleType__")
+        if self.__rapuiSerialiseType__ == T_RAPUI_TUPLE:
+            key = "Tuple: " + self.__tupleType__
 
-        elif getattr(self, "__rapuiSerialiseType__") == T_RAPUI_PAYLOAD:
+        elif self.__rapuiSerialiseType__ == T_RAPUI_PAYLOAD:
             assert hasattr(self, "filt"), "Payload is missing filt"
             if "key" in self.filt:
                 key = "Payload: key=" + self.filt["key"]
@@ -78,7 +75,7 @@ class Jsonable(object):
                 key = "Payload: " + str(self.filt)
 
         else:
-            key = "Jsonable: " + getattr(self, "__rapuiSerialiseType__")
+            key = "Jsonable: " + self.__rapuiSerialiseType__
 
         return key
 
@@ -100,9 +97,7 @@ class Jsonable(object):
         from .Tuple import TupleField
 
         if isinstance(value, TupleField):
-            value = (
-                None if value.defaultValue == None else copy(value.defaultValue)
-            )
+            value = None if value.defaultValue == None else copy(value.defaultValue)
 
         try:
             valueType = V_NULL if value is None else toRapuiType(value)
@@ -316,6 +311,54 @@ class Jsonable(object):
             ):
                 value = enumClass(value)
 
+            # Reconstruct Tuple subclasses for fields annotated with a Tuple
+            # type. Serialised tuples may arrive as plain dicts (no _ct/_c
+            # markers) when the sender has no Tuple class for the value; the
+            # receiving class's annotation drives the coercion.
+            value = self._coerceValueToTypeHint(value, hints.get(name))
+
             setattr(self, name, value)
 
         return self
+
+    def _coerceValueToTypeHint(
+        self, value: typing.Any, typeHint: typing.Any
+    ) -> typing.Any:
+        """Coerce a plain JSON value into the type declared by *typeHint*.
+
+        Currently handles ``vortex.Tuple`` subclasses (and lists of them);
+        other hints pass through unchanged. Plain dicts are validated:
+        unknown keys raise ``KeyError``. Values that are neither a dict nor
+        ``None`` for a Tuple-typed field raise ``ValueError``.
+        """
+        from .Tuple import Tuple
+
+        tupleClass = utilTupleClassFromTypeHint(typeHint)
+        if tupleClass is not None:
+            if isinstance(value, tupleClass):
+                return value
+            if isinstance(value, dict):
+                extraKeys = set(value) - set(tupleClass.__fieldNames__)
+                if extraKeys:
+                    raise KeyError(
+                        f"Unexpected keys for {tupleClass.__name__}:"
+                        f" {sorted(extraKeys)}"
+                    )
+                return Tuple.restfulJsonDictToTupleWithValidation(value, tupleClass)
+            if value is None:
+                return None
+            raise ValueError(
+                f"Expected dict for {tupleClass.__name__}, got {type(value).__name__}"
+            )
+
+        origin = typing.get_origin(typeHint)
+        if origin is list and isinstance(value, list):
+            args = typing.get_args(typeHint)
+            if args:
+                elementClass = utilTupleClassFromTypeHint(args[0])
+                if elementClass is not None:
+                    return [
+                        self._coerceValueToTypeHint(item, args[0]) for item in value
+                    ]
+
+        return value

vortexpy-6.3.0/vortex/Jsonable_tuple_dict_coercion_test.py

@@ -0,0 +1,144 @@
+# ruff: noqa: C408, N999
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+
+"""Tests for Jsonable.fromJsonDict coercion of plain dicts into Tuple fields."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import StrEnum
+
+import pytest
+
+from vortex.SerialiseUtil import ISO8601
+from vortex.Tuple import Tuple, TupleField, addTupleType
+
+
+class _ColorE(StrEnum):
+    RED = "red"
+    BLUE = "blue"
+
+
+@addTupleType
+class _InnerTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonableCoercionInnerTuple"
+    fieldMap: dict[str, str] = TupleField()
+    color: _ColorE = TupleField()
+
+
+@addTupleType
+class _OuterTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonableCoercionOuterTuple"
+    inner: _InnerTuple = TupleField()
+    inners: list[_InnerTuple] = TupleField()
+    optInner: _InnerTuple | None = TupleField()
+
+
+@addTupleType
+class _DatetimeInnerTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonableCoercionDatetimeInnerTuple"
+    when: datetime = TupleField()
+
+
+@addTupleType
+class _DatetimeOuterTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonableCoercionDatetimeOuterTuple"
+    inner: _DatetimeInnerTuple = TupleField()
+
+
+def test_from_json_dict_coerces_nested_tuple_field() -> None:
+    data = dict(
+        inner=dict(fieldMap=dict(payload="body"), color="blue"),
+        inners=[dict(fieldMap=dict(x="y"), color="red")],
+        optInner=None,
+    )
+    result = _OuterTuple().fromJsonDict(data)
+
+    assert isinstance(result.inner, _InnerTuple), (
+        "plain dict inner must coerce to declared Tuple type"
+    )
+    assert result.inner.fieldMap == dict(payload="body"), (
+        "fieldMap must coerce nested dict values"
+    )
+    assert result.inner.color == _ColorE.BLUE, (
+        "enum field must coerce from string value"
+    )
+    assert isinstance(result.inners, list), "inners must be a list"
+    assert len(result.inners) == 1, "inners must contain one item"
+    assert isinstance(result.inners[0], _InnerTuple), (
+        "list item must coerce to declared Tuple type"
+    )
+    assert result.inners[0].color == _ColorE.RED, (
+        "list item enum must coerce from string value"
+    )
+    assert result.optInner is None, "optInner None must be preserved"
+
+
+def test_from_json_dict_coerces_optional_nested_tuple_field() -> None:
+    data = dict(
+        inner=dict(fieldMap=dict(), color="red"),
+        inners=[],
+        optInner=dict(fieldMap=dict(k="v"), color="blue"),
+    )
+    result = _OuterTuple().fromJsonDict(data)
+
+    assert isinstance(result.optInner, _InnerTuple), (
+        "optional inner dict must coerce to declared Tuple type"
+    )
+    assert result.optInner.color == _ColorE.BLUE, (
+        "optional inner enum must coerce from string value"
+    )
+
+
+def test_from_json_dict_coerces_nested_tuple_with_iso_datetime() -> None:
+    when = datetime(2024, 6, 15, 10, 30, 45, 123456, tzinfo=UTC)
+    data = dict(
+        inner=dict(when=when.strftime(ISO8601)),
+    )
+    result = _DatetimeOuterTuple().fromJsonDict(data)
+
+    assert isinstance(result.inner.when, datetime), (
+        "nested tuple datetime field must decode to datetime"
+    )
+    assert result.inner.when == when, "nested tuple datetime field must preserve value"
+
+
+def test_from_json_dict_enum_inside_nested_tuple_reconstructs() -> None:
+    data = dict(inner=dict(fieldMap=dict(), color="blue"), inners=[], optInner=None)
+    result = _OuterTuple().fromJsonDict(data)
+
+    assert result.inner.color == _ColorE.BLUE, (
+        "nested enum field must reconstruct from string"
+    )
+    assert isinstance(result.inner.color, _ColorE), (
+        "nested enum field must be the enum type"
+    )
+
+
+def test_from_json_dict_missing_required_key_raises_validation_error() -> None:
+    data = dict(
+        inner=dict(fieldMap=dict(payload="body")),  # missing color
+        inners=[],
+        optInner=None,
+    )
+    with pytest.raises((KeyError, TypeError)):
+        _OuterTuple().fromJsonDict(data)
+
+
+def test_from_json_dict_extra_key_raises_validation_error() -> None:
+    data = dict(
+        inner=dict(fieldMap=dict(), color="red", extra=1),
+        inners=[],
+        optInner=None,
+    )
+    with pytest.raises((KeyError, TypeError)):
+        _OuterTuple().fromJsonDict(data)
+
+
+def test_from_json_dict_non_dict_for_tuple_typed_field_raises() -> None:
+    data = dict(inner="not-a-dict", inners=[], optInner=None)
+    with pytest.raises(ValueError):
+        _OuterTuple().fromJsonDict(data)

{vortexpy-6.2.4 → vortexpy-6.3.0}/vortex/SerialiseUtil.py

@@ -12,9 +12,9 @@ import functools
 import logging
 import types
 import typing
-from base64 import b64encode, b64decode
+from base64 import b64decode, b64encode
 from collections import defaultdict
-from datetime import UTC, datetime, date
+from datetime import UTC, date, datetime
 
 import pytz
 from sqlalchemy.orm.collections import InstrumentedList
@@ -114,15 +114,15 @@ def convertFromWkbElement(value):
 
 
 def serialiseWkb(wkb: WKBElement) -> str:
-    from geoalchemy2.shape import to_shape
     import shapely
+    from geoalchemy2.shape import to_shape
 
     return b64encode(shapely.wkb.dumps(to_shape(wkb))).decode()
 
 
 def deserialiseWkb(wkbB64Data: str) -> WKBElement:
-    from geoalchemy2.shape import from_shape
     import shapely
+    from geoalchemy2.shape import from_shape
 
     return from_shape(shapely.wkb.loads(b64decode(wkbB64Data)))
 
@@ -253,9 +253,7 @@ def fromStr(val: str, typeName: str):
     if typeName == T_DATETIME:
         # TODO: Check with ISO8601_JS_REGEXP
         if len(val) == len("2017-06-06T09:40:37.097Z"):
-            return datetime.strptime(val, ISO8601_JS_FORMAT).replace(
-                tzinfo=pytz.UTC
-            )
+            return datetime.strptime(val, ISO8601_JS_FORMAT).replace(tzinfo=pytz.UTC)
 
         if len(val) <= len("2017-06-06 09:40:37.097068"):
             raise ValueError(
@@ -286,7 +284,7 @@ def fromRapuiType(typeName: str):
     return TYPE_MAP_RAPUI_TO_PY[typeName]
 
 
-@functools.lru_cache(maxsize=None)
+@functools.cache
 def utilTypeHintsForClass(cls: type) -> dict[str, typing.Any]:
     """Resolved type hints for a class, cached per class.
 
@@ -328,6 +326,29 @@ def utilEnumClassFromTypeHint(typeHint: typing.Any) -> type[enum.Enum] | None:
     return None
 
 
+def utilTupleClassFromTypeHint(typeHint: typing.Any) -> type | None:
+    """The ``vortex.Tuple`` subclass for a field type hint, or None.
+
+    Handles bare ``SomeTuple``, ``SomeTuple | None`` and
+    ``Optional[SomeTuple]``; every other hint returns None.
+    """
+    from vortex.Tuple import Tuple
+
+    if typeHint is None:
+        return None
+
+    if isinstance(typeHint, type) and issubclass(typeHint, Tuple):
+        return typeHint
+
+    origin = typing.get_origin(typeHint)
+    if origin in (typing.Union, types.UnionType):
+        for arg in typing.get_args(typeHint):
+            if isinstance(arg, type) and issubclass(arg, Tuple):
+                return arg
+
+    return None
+
+
 def toRapuiType(value):
     if value is None:
         return V_NULL

{vortexpy-6.2.4 → vortexpy-6.3.0}/vortex/TupleBson_test.py

@@ -26,6 +26,7 @@ from vortex.tuple_test_fixtures import (
     BsonObjectTypeE,
     BsonOptionalDatetimeTestTuple,
     BsonOptionalFloatTestTuple,
+    BsonOptionalListTestTuple,
     BsonPriorityE,
     BsonTestTuple,
     makeBsonTestTuple,
@@ -71,6 +72,28 @@ class TupleBsonTest(unittest.TestCase):
         self.assertEqual(deserialisedTuple.requiredFloat, 151.0)
         self.assertEqual(deserialisedTuple.optionalFloat, 0.0)
 
+    def testOptionalStrListRoundTrip(self) -> None:
+        origTuple = BsonOptionalListTestTuple(optionalStrList=["low", "high"])
+        bsonDict = origTuple.tupleToBsonJsonDict()
+        deserialisedTuple = Tuple.bsonJsonDictToTupleWithValidation(
+            bsonDict, BsonOptionalListTestTuple
+        )
+        self.assertEqual(deserialisedTuple.optionalStrList, ["low", "high"])
+
+    def testOptionalStrListNoneRoundTrip(self) -> None:
+        origTuple = BsonOptionalListTestTuple(optionalStrList=None)
+        bsonDict = origTuple.tupleToBsonJsonDict()
+        deserialisedTuple = Tuple.bsonJsonDictToTupleWithValidation(
+            bsonDict, BsonOptionalListTestTuple
+        )
+        self.assertIsNone(deserialisedTuple.optionalStrList)
+
+    def testOptionalStrListAbsentDecodesToNone(self) -> None:
+        deserialisedTuple = Tuple.bsonJsonDictToTupleWithValidation(
+            {}, BsonOptionalListTestTuple
+        )
+        self.assertIsNone(deserialisedTuple.optionalStrList)
+
     def testBsonFractionalDoubleParsesAsIntFieldWithWarning(self) -> None:
         bsonDict = validBsonDict()
         bsonDict["aInt"] = 151.7

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

@@ -421,12 +421,8 @@ class TupleDocumentConverterBase:
                     return cls._makeError(field_path, str(exc), ValueError)
             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, list) and get_origin(typeHint) is list:
+            return None
 
         if isinstance(value, dict):
             if get_origin(typeHint) is dict:
@@ -717,6 +713,17 @@ class TupleDocumentConverterBase:
             errors.append(intError)
             return _ConvertResult(_UNSET, errors)
 
+        # Narrow ``list[X] | None`` unions to the list hint for list values
+        # so _checkType and _convertListCollecting see the item hint.
+        if isinstance(value, list) and get_origin(typeHint) is not list:
+            unionListArgs = [
+                unionArg
+                for unionArg in get_args(typeHint)
+                if get_origin(unionArg) is list
+            ]
+            if unionListArgs:
+                typeHint = unionListArgs[0]
+
         typeError = cls._checkType(
             TupleClass, field_path, fieldName, typeHint, value, validator
         )

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

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

{vortexpy-6.2.4 → vortexpy-6.3.0}/vortex/handler/TupleDataOfflineObserverService.py

@@ -108,6 +108,11 @@ class CachedSubscribedData:
     def tuples(self, tuples: list[Tuple]) -> None:
         self.touch()
         self._tuples = tuples
+        if self.subject.is_disposed:
+            # RxJS parity: emitting after disposal is a silent no-op — a
+            # late redelivery after teardown must not crash the payload
+            # path with DisposedException.
+            return
         self.subject.on_next(tuples)
 
     def touch(self) -> None:
@@ -123,6 +128,8 @@ class CachedSubscribedData:
         self.lastServerAskDate = None
         self.lastServerPayloadDate = None
         self._tuples = None
+        if self.subject.is_disposed:
+            return
         self.subject.on_next(None)
 
 
@@ -286,6 +293,20 @@ class TupleDataOfflineObserverService:
             cachedData.flush()
         self._cleanupDeadCaches()
 
+    def unsubscribeAndEvictCache(self, tupleSelector: TupleSelector) -> None:
+        """Evict one selector's cached data and unsubscribe it from the server.
+
+        The selector's cached data is dropped from the in-memory cache
+        entirely — unlike :meth:`flushCache`, which keeps the cache entry
+        for later reuse — and an unsubscribe is sent to the server, queued
+        while the vortex is offline and flushed on reconnect.
+
+        :param tupleSelector: The tuple selector to evict and unsubscribe.
+        """
+        tsStr = tupleSelector.toJsonStr()
+        self._cacheByTupleSelector.pop(tsStr, None)
+        self._utilSendUnsubscribeToServer([tupleSelector])
+
     def promiseFromTupleSelector(
         self,
         tupleSelector: TupleSelector,

{vortexpy-6.2.4 → vortexpy-6.3.0}/vortex/handler/TupleDataOfflineObserverService_test.py

@@ -21,6 +21,7 @@ from twisted.internet import reactor, task
 from twisted.internet.defer import Deferred, DeferredList, succeed
 
 from vortex.handler.TupleDataOfflineObserverService import (
+    CachedSubscribedData,
     TupleDataOfflineObserverService,
 )
 from vortex.Payload import Payload
@@ -159,8 +160,19 @@ def _makeService(
     )
 
 
-@pytest.mark.twisted
-@ensureDeferred
+def test_disposed_subject_drops_late_payload_silently() -> None:
+    cached = CachedSubscribedData(_makeSelector())
+    cached.subject.dispose()
+
+    cached.tuples = _makeTuples("late")
+    assert [t.aString for t in cached.tuples] == ["late"], (
+        "the cache still records the payload — only the subject emission"
+        " is skipped after disposal (RxJS parity: no DisposedException)"
+    )
+
+    cached.flush()  # must not raise DisposedException either
+
+
 async def test_offline_subscribe_emits_stored_tuples(tmp_path, monkeypatch) -> None:
     storage = await _makeStorage(tmp_path)
     tupleSelector = _makeSelector()
@@ -413,6 +425,41 @@ async def test_flush_timer_and_flush_cache(tmp_path, monkeypatch) -> None:
         service.shutdown()
 
 
+@pytest.mark.twisted
+@ensureDeferred
+async def test_unsubscribeAndEvictCache_evicts_and_sends_unsubscribe(
+    tmp_path, monkeypatch
+) -> None:
+    tupleSelector = _makeSelector()
+
+    harness = _VortexHarness(monkeypatch)
+    harness.goOnline()
+
+    service = _makeService(None)
+    collector = _EmissionCollector()
+    subscription = service.subscribeToTupleSelector(tupleSelector).subscribe(collector)
+    try:
+        tsStr = tupleSelector.toJsonStr()
+        assert tsStr in service._cacheByTupleSelector, (
+            "a live subscription holds a cache entry for its selector"
+        )
+
+        service.unsubscribeAndEvictCache(tupleSelector)
+
+        assert tsStr not in service._cacheByTupleSelector, (
+            "the evicted selector's cached data is dropped from the cache"
+            " entirely — unlike flushCache, which retains the entry"
+        )
+        unsubscribeEnvelopes = [
+            e for e in harness.sentEnvelopes() if e.filt["unsubscribe"] is True
+        ]
+        assert len(unsubscribeEnvelopes) == 1
+        assert unsubscribeEnvelopes[0].filt["tupleSelector"] == tupleSelector
+    finally:
+        subscription.dispose()
+        service.shutdown()
+
+
 @pytest.mark.twisted
 @ensureDeferred
 async def test_pending_unsubscribe_flushes_on_reconnect(tmp_path, monkeypatch) -> None:

{vortexpy-6.2.4 → vortexpy-6.3.0}/vortex/tuple_test_fixtures.py

@@ -172,6 +172,12 @@ class BsonOptionalDatetimeTestTuple(Tuple):
     optionalDate: datetime | None = TupleField()
 
 
+@addTupleType
+class BsonOptionalListTestTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.BsonOptionalListTestTuple"
+    optionalStrList: list[str] | None = TupleField(None)
+
+
 @addTupleType
 class BsonDatetimeFormatTestTuple(Tuple):
     __tupleType__ = "flyingion.vortex.BsonDatetimeFormatTestTuple"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 6.2.4
+Version: 6.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-6.2.4 → vortexpy-6.3.0}/vortexpy.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 example/TwistedDeferredTimeout.py
@@ -14,6 +15,7 @@ vortex/DataWrapTuple.py
 vortex/DeferUtil.py
 vortex/DeferUtil_test.py
 vortex/Jsonable.py
+vortex/Jsonable_tuple_dict_coercion_test.py
 vortex/MtlsAuthorizedClientRegistry.py
 vortex/MtlsAuthorizedClientRegistry_test.py
 vortex/MtlsServerSslOptions.py