vortexpy 4.3.6__tar.gz → 4.3.9__tar.gz

{vortexpy-4.3.6 → vortexpy-4.3.9}/PKG-INFO

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

{vortexpy-4.3.6 → vortexpy-4.3.9}/pyproject.toml

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

@@ -290,10 +290,18 @@ def fromRapuiType(typeName: str):
 def utilTypeHintsForClass(cls: type) -> dict[str, typing.Any]:
     """Resolved type hints for a class, cached per class.
 
+    Tuple classes resolve through ``Tuple.typeHints()`` — the canonical
+    per-class store; other classes are cached by this function's
+    ``lru_cache``.
+
     Returns an empty dict when hints can not be resolved (for example
     unresolvable forward references) — enum coercion degrades to no-op.
     """
+    from vortex.Tuple import Tuple
+
     try:
+        if issubclass(cls, Tuple):
+            return cls.typeHints()
         return typing.get_type_hints(cls)
     except Exception:
         return {}

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/Tuple.py

@@ -17,6 +17,7 @@ from datetime import datetime
 from typing import Dict, Optional, Any
 from typing import List
 from typing import Type
+from typing import get_type_hints
 
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.orm.properties import RelationshipProperty
@@ -28,6 +29,9 @@ from .SerialiseUtil import ISO8601
 from .SerialiseUtil import T_RAPUI_TUPLE
 from .SerialiseUtil import WKBElement
 from .SerialiseUtil import convertFromWkbElement
+from .SerialiseUtil import datetimeToBson
+from .SerialiseUtil import datetimeToBsonMicroseconds
+from .SerialiseUtil import requireAwareDatetime
 
 logger = logging.getLogger(__name__)
 
@@ -312,6 +316,28 @@ class TupleField:
         self.jsonExclude = jsonExclude
         self.bsonDatetimeFormat = bsonDatetimeFormat
 
+    def toBson(self, value: Any) -> Any:
+        """Convert a datetime to this field's BSON storage format.
+
+        Non-datetime values pass through unchanged, so every Mongo
+        filter value can be wrapped uniformly. Naive datetimes raise
+        ``TypeError``.
+        """
+        if not isinstance(value, datetime):
+            return value
+        aware = requireAwareDatetime(value)
+        if self.bsonDatetimeFormat is None:
+            return datetimeToBson(aware)
+        if self.bsonDatetimeFormat is BsonDatetimeFormatE.standardMsIntEpoch:
+            return datetimeToBson(aware)
+        if self.bsonDatetimeFormat is BsonDatetimeFormatE.standardUsIntEpoch:
+            return datetimeToBsonMicroseconds(aware)
+        if self.bsonDatetimeFormat is BsonDatetimeFormatE.standardMsBsonDate:
+            return aware
+        raise NotImplementedError(
+            f"Unsupported BsonDatetimeFormatE {self.bsonDatetimeFormat!r}"
+        )
+
 
 class PolymorphicTupleTypeFieldArg:
     def __init__(self, fieldName: str):
@@ -642,6 +668,51 @@ class Tuple(Jsonable, _TupleToPlainJsonMixin, _TupleToSqlaJsonMixin):
     def tupleFieldNames(cls) -> List[str]:
         return cls.__fieldNames__
 
+    @classmethod
+    def typeHints(cls) -> Dict[str, Any]:
+        """Type Hints
+
+        Resolved type hints for this class, computed once and stored on the
+        class itself.
+
+        Resolution is lazy: tuples reference each other with forward
+        references, so hints can only be resolved after all imports
+        complete. Failures are not stored — if the hints are unresolvable
+        the exception propagates and the next call retries.
+
+        The hints are stored in the class's own ``__dict__`` so a subclass
+        always resolves and stores its own hints, never a base class's.
+
+        :return: The resolved type hints for this class.
+        """
+        cachedHints = cls.__dict__.get("__cachedTypeHints__")
+        if cachedHints is not None:
+            return cachedHints
+
+        hints = get_type_hints(cls)
+        cls.__cachedTypeHints__ = hints
+        return hints
+
+    @classmethod
+    def typeHintsWithExtras(cls) -> Dict[str, Any]:
+        """Type Hints With Extras
+
+        Resolved type hints for this class, including ``Annotated`` extras,
+        computed once and stored on the class itself.
+
+        Resolution is lazy and failures are not stored, same as
+        :meth:`typeHints`.
+
+        :return: The resolved type hints for this class, with extras.
+        """
+        cachedHints = cls.__dict__.get("__cachedTypeHintsWithExtras__")
+        if cachedHints is not None:
+            return cachedHints
+
+        hints = get_type_hints(cls, include_extras=True)
+        cls.__cachedTypeHintsWithExtras__ = hints
+        return hints
+
     @classmethod
     def tupleJsonSchema(cls) -> "JsonSchemaNodeTuple":
         """Tuple JSON Schema

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/TupleBson.py

@@ -43,7 +43,6 @@ from .SerialiseUtil import WKBElement
 from .SerialiseUtil import convertFromWkbElement
 from .SerialiseUtil import datetimeFromBson
 from .SerialiseUtil import datetimeToBson
-from .SerialiseUtil import datetimeToBsonMicroseconds
 from .SerialiseUtil import requireAwareDatetime
 from .Tuple import BsonDatetimeFormatE
 from .Tuple import TupleField
@@ -65,24 +64,6 @@ class TupleBsonConverter(TupleDocumentConverterBase):
             return tupleField.bsonDatetimeFormat
         return None
 
-    @classmethod
-    def _utilDatetimeToBsonStorageValue(
-        cls,
-        value: datetime,
-        bsonDatetimeFormat: BsonDatetimeFormatE | None,
-    ) -> datetime | int:
-        if bsonDatetimeFormat is None:
-            return datetimeToBson(value)
-        if bsonDatetimeFormat is BsonDatetimeFormatE.standardMsIntEpoch:
-            return datetimeToBson(value)
-        if bsonDatetimeFormat is BsonDatetimeFormatE.standardUsIntEpoch:
-            return datetimeToBsonMicroseconds(value)
-        if bsonDatetimeFormat is BsonDatetimeFormatE.standardMsBsonDate:
-            return requireAwareDatetime(value)
-        raise NotImplementedError(
-            f"Unsupported BsonDatetimeFormatE {bsonDatetimeFormat!r}"
-        )
-
     @classmethod
     def _utilCoerceIntOrFloatEpochToDatetime(
         cls,
@@ -145,7 +126,7 @@ class TupleBsonConverter(TupleDocumentConverterBase):
 
         def convert(
             value: Any,
-            bsonDatetimeFormat: BsonDatetimeFormatE | None = None,
+            tupleField: TupleField | None = None,
         ) -> Any:
             if isinstance(value, list):
                 return [convert(item) for item in value]
@@ -165,17 +146,18 @@ class TupleBsonConverter(TupleDocumentConverterBase):
                 return None
 
             if isinstance(value, datetime):
-                return cls._utilDatetimeToBsonStorageValue(value, bsonDatetimeFormat)
+                if tupleField is None:
+                    return datetimeToBson(value)
+                return tupleField.toBson(value)
 
             return value
 
         for shortName, normalName in tuple_.__shortFieldNamesMap__.items():
             tupleField = getattr(type(tuple_), normalName, None)
-            fieldFormat: BsonDatetimeFormatE | None = None
-            if isinstance(tupleField, TupleField):
-                fieldFormat = tupleField.bsonDatetimeFormat
+            if not isinstance(tupleField, TupleField):
+                tupleField = None
 
-            value = convert(getattr(tuple_, normalName), fieldFormat)
+            value = convert(getattr(tuple_, normalName), tupleField)
             if value is None and not includeNones:
                 continue
             if value is False and not includeFalse:

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/TupleBson_test.py

@@ -250,6 +250,33 @@ class TupleBsonTest(unittest.TestCase):
         )
         self.assertEqual(deserialisedTuple.at, aware)
 
+    def testTupleFieldToBsonConvertsDatetimePerFormat(self) -> None:
+        aware = datetime(2020, 1, 2, 3, 4, 5, 678000, tzinfo=UTC)
+        self.assertEqual(
+            BsonDatetimeFormatTestTuple.defaultMsDate.toBson(aware),
+            datetimeToBson(aware),
+        )
+        self.assertEqual(
+            BsonDatetimeFormatTestTuple.microsecondDate.toBson(aware),
+            datetimeToBsonMicroseconds(aware),
+        )
+        self.assertEqual(
+            BsonDatetimeFormatTestTuple.bsonDateField.toBson(aware),
+            aware,
+        )
+
+    def testTupleFieldToBsonPassesThroughNonDatetimeValues(self) -> None:
+        field = BsonDatetimeFormatTestTuple.defaultMsDate
+        self.assertEqual(field.toBson("2026-10-23"), "2026-10-23")
+        self.assertEqual(field.toBson(1577934245678), 1577934245678)
+        self.assertIs(field.toBson(True), True)
+        self.assertIsNone(field.toBson(None))
+
+    def testTupleFieldToBsonRejectsNaiveDatetime(self) -> None:
+        naive = datetime(2020, 1, 2, 3, 4, 5, 678000)
+        with self.assertRaises(TypeError):
+            BsonDatetimeFormatTestTuple.defaultMsDate.toBson(naive)
+
 
 class TupleBsonCollectingTest(unittest.TestCase):
     def testSingleBadScalarCollectsErrorAndPopulatesOtherFields(self) -> None:

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/TupleDocumentConverter.py

@@ -20,7 +20,6 @@ from typing import TYPE_CHECKING, Annotated, Any, NamedTuple, Optional, Type
 
 from typing import Union, get_args
 from typing import get_origin
-from typing import get_type_hints
 
 from .Tuple import BsonDatetimeFormatE
 from .Tuple import TUPLE_TYPES_BY_NAME
@@ -751,7 +750,7 @@ class TupleDocumentConverterBase:
     ) -> TupleValidationResult:
         errors: list[TupleValidationError] = []
 
-        if not get_type_hints(TupleClass):
+        if not TupleClass.typeHints():
             errors.append(
                 cls._makeError(_ROOT_PATH, f"{TupleClass} has no annotations")
             )
@@ -759,8 +758,8 @@ class TupleDocumentConverterBase:
 
         TupleClass = cls._resolveConcreteClass(TupleClass, jsonDict, errors)
 
-        typeHints = get_type_hints(TupleClass)
-        extraTypeHits = get_type_hints(TupleClass, include_extras=True)
+        typeHints = TupleClass.typeHints()
+        extraTypeHits = TupleClass.typeHintsWithExtras()
 
         newTuple = TupleClass()
 

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/TupleTest.py

@@ -9,10 +9,13 @@
 import datetime
 import json
 
+from typing import Annotated, get_type_hints
+from unittest import mock
+
 from twisted.trial import unittest
 
 from vortex.TestTuple import TestSubTuple, TestTuple
-from vortex.Tuple import TupleHash
+from vortex.Tuple import Tuple, TupleField, TupleHash
 
 
 def makeTupleA():
@@ -124,3 +127,78 @@ class TuplePyTest(unittest.TestCase):
         self.assertFalse(
             hashA1 in {hashB1: None}, "TupleHash in fail, A1 in {B1:None}"
         )
+
+
+class TupleTypeHintsTest(unittest.TestCase):
+    """Tests for the lazy per-class type hint storage on ``Tuple``."""
+
+    def testTypeHintsCachedOnClass(self):
+        """Two calls return the same dict; get_type_hints runs once."""
+
+        class CachedHintsTuple(Tuple):
+            aInt: int = TupleField()
+            aStr: str = TupleField()
+
+        countingHints = mock.Mock(side_effect=get_type_hints)
+        with mock.patch("vortex.Tuple.get_type_hints", countingHints):
+            hints1 = CachedHintsTuple.typeHints()
+            hints2 = CachedHintsTuple.typeHints()
+
+        self.assertIs(hints1, hints2)
+        self.assertEqual(countingHints.call_count, 1)
+        self.assertIs(hints1["aInt"], int)
+        self.assertIs(hints1["aStr"], str)
+
+    def testTypeHintsWithExtrasCachedOnClass(self):
+        """Annotated extras are kept; get_type_hints runs once."""
+
+        class CachedExtrasTuple(Tuple):
+            aInt: Annotated[int, "marker"] = TupleField()
+
+        countingHints = mock.Mock(side_effect=get_type_hints)
+        with mock.patch("vortex.Tuple.get_type_hints", countingHints):
+            hints1 = CachedExtrasTuple.typeHintsWithExtras()
+            hints2 = CachedExtrasTuple.typeHintsWithExtras()
+
+        self.assertIs(hints1, hints2)
+        self.assertEqual(countingHints.call_count, 1)
+        self.assertEqual(
+            countingHints.call_args, mock.call(CachedExtrasTuple, include_extras=True)
+        )
+        self.assertEqual(hints1["aInt"].__metadata__, ("marker",))
+
+    def testTypeHintsSubclassStoresOwnHints(self):
+        """A subclass never returns a base class's cached hints."""
+
+        class ParentHintsTuple(Tuple):
+            aStr: str = TupleField()
+
+        class ChildHintsTuple(ParentHintsTuple):
+            aInt: int = TupleField()
+
+        parentHints = ParentHintsTuple.typeHints()
+        childHints = ChildHintsTuple.typeHints()
+
+        self.assertIsNot(parentHints, childHints)
+        self.assertIs(parentHints["aStr"], str)
+        self.assertNotIn("aInt", parentHints)
+        self.assertIs(childHints["aStr"], str)
+        self.assertIs(childHints["aInt"], int)
+
+    def testTypeHintsFailureNotCached(self):
+        """A failed resolution propagates and the next call retries."""
+
+        class FailingHintsTuple(Tuple):
+            aInt: int = TupleField()
+
+        flakyHints = mock.Mock(
+            side_effect=[NameError("unresolvable"), {"aInt": int}]
+        )
+        with mock.patch("vortex.Tuple.get_type_hints", flakyHints):
+            self.assertRaises(NameError, FailingHintsTuple.typeHints)
+            hints = FailingHintsTuple.typeHints()
+            again = FailingHintsTuple.typeHints()
+
+        self.assertEqual(hints, {"aInt": int})
+        self.assertIs(hints, again)
+        self.assertEqual(flakyHints.call_count, 2)

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/VortexServer.py

@@ -154,9 +154,9 @@ class VortexServer(VortexABC):
                 )
 
             httpSessionConns = VortexSessionI(httpSession).connections
-            for oldConn in list(httpSessionConns.values()):
-                if oldConn is not vortexConnection:
-                    oldConn.close()
+            existingConn = httpSessionConns.get(vortexUuid)
+            if existingConn is not None and existingConn is not vortexConnection:
+                existingConn.close()
             httpSessionConns[vortexUuid] = vortexConnection
 
         if vortexUuid in self._connectionByVortexUuid:

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/VortexServer_test.py

@@ -84,12 +84,26 @@ class VortexServerConnectionClosedTest(SynchronousTestCase):
         server.connectionOpened(session, conn_a)
         server.connectionOpened(session, conn_b)
 
+        # A new connection with a different vortexUuid must not close the
+        # existing same-session connection (two browser tabs stay live).
         conns = VortexSessionI(session).connections
+        self.assertEqual(conns.get("uuid-a"), conn_a)
+        self.assertEqual(conns.get("uuid-b"), conn_b)
+
+        # Reconnecting with the same vortexUuid replaces the old connection.
+        conn_a2 = _MockServerConnection(
+            server, "uuid-a", "peek-office-app", session
+        )
+        server.connectionOpened(session, conn_a2)
+
+        self.assertIs(conns.get("uuid-a"), conn_a2)
         self.assertEqual(conns.get("uuid-b"), conn_b)
-        self.assertNotIn("uuid-a", conns)
 
+        # The replaced connection's teardown is idempotent and does not
+        # disturb the surviving connections.
         server.connectionClosed(conn_a)
 
+        self.assertIs(conns.get("uuid-a"), conn_a2)
         self.assertEqual(conns.get("uuid-b"), conn_b)
         self.assertIn("uuid-b", server._connectionByVortexUuid)
 

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortex/__init__.py

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

{vortexpy-4.3.6 → vortexpy-4.3.9}/vortexpy.egg-info/PKG-INFO

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