vortexpy 6.0.1__tar.gz → 6.1.0__tar.gz

{vortexpy-6.0.1 → vortexpy-6.1.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "6.0.1"
+version = "6.1.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.0.1 → vortexpy-6.1.0}/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-6.0.1 → vortexpy-6.1.0}/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
@@ -648,6 +649,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-6.0.1 → vortexpy-6.1.0}/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-6.0.1 → vortexpy-6.1.0}/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)