vortexpy 6.2.6__tar.gz → 6.3.1__tar.gz

{vortexpy-6.2.6 → vortexpy-6.3.1}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "6.2.6"
+version = "6.3.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-6.2.6 → vortexpy-6.3.1}/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.1/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.6 → vortexpy-6.3.1}/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.6 → vortexpy-6.3.1}/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.6 → vortexpy-6.3.1}/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.6 → vortexpy-6.3.1}/vortex/VortexServer.py

@@ -27,7 +27,6 @@ from zope.interface.declarations import implementer
 from .DeferUtil import isMainThread
 from .DeferUtil import vortexLogFailure
 from .VortexSession import IVortexSession
-from .VortexSession import VortexTcpSession
 from .PayloadEnvelope import PayloadEnvelope
 from .PayloadEnvelope import VortexMsgList
 from .PayloadFilterKeys import rapuiServerEcho
@@ -395,23 +394,3 @@ class VortexSession(object):
 
 
 registerAdapter(VortexSession, Session, VortexSessionI)
-
-
-def _tcpSessionVortexSessionIAdapter(session: VortexTcpSession) -> VortexSession:
-    """Adapt a :class:`VortexTcpSession` to :class:`VortexSessionI`.
-
-    Twisted ``Session`` instances cache adapters through
-    ``Componentized.__conform__``; the TCP stub is not a ``Componentized``,
-    so the adapter is cached on the stub's own component store — without
-    this, every adaptation would return a fresh adapter with an empty
-    ``connections`` dict and ``connectionOpened`` registrations would be
-    lost.
-    """
-    adapter = session.getComponent(VortexSessionI)
-    if adapter is None:
-        adapter = VortexSession(session)
-        session.setComponent(VortexSessionI, adapter)
-    return adapter
-
-
-registerAdapter(_tcpSessionVortexSessionIAdapter, VortexTcpSession, VortexSessionI)

{vortexpy-6.2.6 → vortexpy-6.3.1}/vortex/VortexServer_test.py

@@ -14,7 +14,6 @@ from vortex.VortexServer import (
     VortexSessionI,
 )
 from vortex.VortexServerWebsocket import VortexWebsocketServerProtocol
-from vortex.VortexSession import VortexTcpSession
 
 
 class _MockServerConnection:
@@ -218,43 +217,6 @@ class VortexSessionAdapterTimeoutTest(SynchronousTestCase):
         self.assertEqual(session.sessionTimeout, HEART_BEAT_TIMEOUT)
 
 
-class VortexTcpSessionAdapterTest(SynchronousTestCase):
-    def testTcpStubAdaptsToVortexSessionI(self) -> None:
-        stub = VortexTcpSession(ip="1.2.3.4", vortexName="remote")
-
-        adapter = VortexSessionI(stub)
-
-        self.assertEqual(adapter.connections, {})
-
-    def testTcpStubAdaptationIsCached(self) -> None:
-        stub = VortexTcpSession(ip="1.2.3.4", vortexName="remote")
-
-        first = VortexSessionI(stub)
-        first.connections["uuid-a"] = object()
-
-        self.assertIs(VortexSessionI(stub), first)
-        self.assertIn("uuid-a", VortexSessionI(stub).connections)
-
-    def testTcpStubTimeoutRaisedToHeartbeatFloor(self) -> None:
-        stub = VortexTcpSession(ip="1.2.3.4", vortexName="remote")
-        stub.sessionTimeout = 5
-
-        VortexSessionI(stub)
-
-        self.assertEqual(stub.sessionTimeout, HEART_BEAT_TIMEOUT)
-
-    def testConnectionOpenedAndClosedWithTcpStub(self) -> None:
-        vortexServer = VortexServer("test-server")
-        stub = VortexTcpSession(ip="1.2.3.4", vortexName="remote")
-        conn = _MockServerConnection(vortexServer, "uuid-a", "remote", stub)
-
-        vortexServer.connectionOpened(stub, conn)
-        self.assertIn("uuid-a", VortexSessionI(stub).connections)
-
-        vortexServer.connectionClosed(conn)
-        self.assertNotIn("uuid-a", VortexSessionI(stub).connections)
-
-
 class VortexWebsocketServerProtocolConnectionLostTest(SynchronousTestCase):
     def testConnectionLostTwiceDoesNotRaise(self) -> None:
         vortex_server = VortexServer("test-server")

{vortexpy-6.2.6 → vortexpy-6.3.1}/vortex/VortexSession.py

@@ -65,17 +65,12 @@ class VortexTcpSession:
 
     TCP connections have no HTTP session.  This stub exposes the subset of
     the Twisted ``Session`` API that vortex code uses (``uid``, ``touch``,
-    ``notifyOnExpire``, ``expire``, ``getComponent``, ``setComponent``,
-    ``sessionTimeout``) so the rest of the codebase can treat all sessions
-    uniformly.
+    ``notifyOnExpire``, ``expire``, ``getComponent``, ``setComponent``) so
+    the rest of the codebase can treat all sessions uniformly.
 
     A :class:`VortexSession` is attached immediately on construction.
     """
 
-    # Mirrors twisted.web.server.Session.sessionTimeout; the
-    # VortexSessionI adapter factory in VortexServer reads and raises it.
-    sessionTimeout = 900
-
     def __init__(self, ip: str, vortexName: str):
         self.uid: bytes = uuid4().bytes
         self._expireCallbacks = []

{vortexpy-6.2.6 → vortexpy-6.3.1}/vortex/__init__.py

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

{vortexpy-6.2.6 → vortexpy-6.3.1}/vortex/handler/TupleDataObservableHandler_test.py

@@ -501,28 +501,25 @@ class _FailingProvider(TupleDataProviderABC):
 
 @pytest.mark.twisted
 @ensureDeferred
-async def test_provider_failure_sends_error_response() -> None:
+async def test_provider_failure_sends_error_response(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _patchFactoryOnline(monkeypatch)
     handler = TupleDataObservableHandler("testObservable")
-    handler.addTupleProvider(_TUPLE_NAME, _FailingProvider())
-    sendResponseCalls: list[bytes] = []
-
-    def sendResponse(vortexMsg: bytes) -> Deferred[None]:
-        sendResponseCalls.append(vortexMsg)
-        return succeed(None)
-
-    with patch(
-        "vortex.handler.TupleDataObservableHandler.VortexFactory.isVortexUuidOnline",
-        return_value=True,
-    ):
-        await handler._process(
-            _pollEnvelope(), _VORTEX_UUID, "client-vortex", sendResponse
-        )
+    handler.addTupleProvider(TUPLE_NAME, _FailingProvider())
+    sent: list[VortexMsgList | bytes] = []
+    tupleSelector = TupleSelector(name=TUPLE_NAME)
 
-    assert len(sendResponseCalls) == 1, (
-        "provider failure must send an error response, not silence"
+    await handler._process(
+        _pollEnvelope(tupleSelector),
+        REMOTE_UUID,
+        "remote-vortex",
+        _sendResponse(sent),
     )
 
-    errorEnvelope = await PayloadEnvelope().fromVortexMsgDefer(sendResponseCalls[0])
+    assert len(sent) == 1, "provider failure must send an error response, not silence"
+
+    errorEnvelope = await PayloadEnvelope().fromVortexMsgDefer(sent[0])
     assert errorEnvelope.result not in (None, True), (
         "error response result must fail the client resultCheck"
     )
@@ -530,5 +527,5 @@ async def test_provider_failure_sends_error_response() -> None:
         "error response must carry the provider error text"
     )
     assert (
-        errorEnvelope.filt["tupleSelector"].toJsonStr() == _TUPLE_SELECTOR.toJsonStr()
+        errorEnvelope.filt["tupleSelector"].toJsonStr() == tupleSelector.toJsonStr()
     ), "error response must preserve the request filt"

{vortexpy-6.2.6 → vortexpy-6.3.1}/vortex/handler/TupleDataObservableProxyHandler.py

@@ -430,9 +430,8 @@ class TupleDataObservableProxyHandler(TupleDataObservableCache):
 
         # Send the vortex messages
         for vortexUuid in observingUuids:
-            # This method runs on a thread-pool thread; callLater is
-            # reactor-thread-only, so schedule with thread-safe callFromThread.
-            reactor.callFromThread(
+            reactor.callLater(
+                0,
                 self._sendVortexMsgInReactor,
                 vortexMsg=vortexMsg,
                 destVortexUuid=vortexUuid,

{vortexpy-6.2.6 → vortexpy-6.3.1}/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,