vortexpy 4.3.4__tar.gz → 4.3.5__tar.gz

{vortexpy-4.3.4 → vortexpy-4.3.5}/PKG-INFO

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

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

@@ -2,6 +2,7 @@
 # See LICENSE for the full license text.
 
 from datetime import UTC, datetime
+from unittest.mock import patch
 
 from ddt import data, ddt
 import unittest
@@ -12,6 +13,7 @@ from vortex.tuple_test_fixtures import (
     BsonEnumTestTuple,
     BsonObjectTypeE,
     BsonOptionalDatetimeTestTuple,
+    BsonOptionalFloatTestTuple,
     BsonPriorityE,
     BsonTestTuple,
     makeBsonTestTuple,
@@ -49,6 +51,28 @@ class TupleBsonTest(unittest.TestCase):
         deserialisedTuple = self._testSerialisation(origTuple)
         self.assertEqual(TupleHash(origTuple), TupleHash(deserialisedTuple))
 
+    def testBsonIntegerParsesAsOptionalFloatField(self) -> None:
+        deserialisedTuple = Tuple.bsonJsonDictToTupleWithValidation(
+            dict(requiredFloat=151, optionalFloat=0),
+            BsonOptionalFloatTestTuple,
+        )
+        self.assertEqual(deserialisedTuple.requiredFloat, 151.0)
+        self.assertEqual(deserialisedTuple.optionalFloat, 0.0)
+
+    def testBsonFractionalDoubleParsesAsIntFieldWithWarning(self) -> None:
+        bsonDict = validBsonDict()
+        bsonDict["aInt"] = 151.7
+        with patch(
+            "vortex.TupleDocumentConverter.logger.warning"
+        ) as mockWarning:
+            deserialisedTuple = Tuple.bsonJsonDictToTupleWithValidation(
+                bsonDict, BsonTestTuple
+            )
+        self.assertEqual(deserialisedTuple.aInt, 151)
+        mockWarning.assert_called_once()
+        warningMessage = mockWarning.call_args[0][0]
+        self.assertIn("lost precision", warningMessage)
+
     def testDatetimeRoundTrip(self) -> None:
         origTuple = BsonOptionalDatetimeTestTuple()
         origTuple.requiredDate = datetime(2020, 1, 2, 3, 4, 5, 678000, tzinfo=UTC)

{vortexpy-4.3.4 → vortexpy-4.3.5}/vortex/TupleDocumentConverter.py

@@ -15,6 +15,7 @@ Subclasses supply datetime and plain-dict coercion at the document boundary.
 from __future__ import annotations
 
 import enum
+import logging
 from typing import TYPE_CHECKING, Annotated, Any, NamedTuple, Optional, Type
 
 from typing import Union, get_args
@@ -29,6 +30,8 @@ from .Tuple import TupleFieldValidatorABC
 if TYPE_CHECKING:
     from .Tuple import Tuple
 
+logger = logging.getLogger(__name__)
+
 _UNSET = object()
 _ROOT_PATH = "$"
 
@@ -287,6 +290,90 @@ class TupleDocumentConverterBase:
 
         return value, None
 
+    @classmethod
+    def _scalarTypeFromHint(cls, typeHint: Any, scalarType: type) -> bool:
+        """Return whether typeHint is ``scalarType`` or ``scalarType | None`` only."""
+        if typeHint is scalarType:
+            return True
+
+        unionArgs = get_args(typeHint)
+        if not unionArgs:
+            return False
+
+        nonNoneArgs = [
+            unionArg for unionArg in unionArgs if unionArg is not type(None)
+        ]
+        return len(nonNoneArgs) == 1 and nonNoneArgs[0] is scalarType
+
+    @classmethod
+    def _floatTypeFromHint(cls, typeHint: Any) -> bool:
+        """Return whether typeHint accepts float (including ``float | None``)."""
+        return cls._scalarTypeFromHint(typeHint, float)
+
+    @classmethod
+    def _tryParseFloatFieldValue(
+        cls,
+        field_path: str,
+        fieldName: str,
+        TupleClass: Type[Tuple],
+        typeHint: Any,
+        value: Any,
+    ) -> tuple[Any, TupleValidationError | None]:
+        """Parse JSON integer tokens as ``float`` when the field type is ``float``."""
+        if value is None:
+            return value, None
+
+        if not cls._floatTypeFromHint(typeHint):
+            return value, None
+
+        if isinstance(value, float):
+            return value, None
+
+        if isinstance(value, int) and not isinstance(value, bool):
+            return float(value), None
+
+        return value, None
+
+    @classmethod
+    def _intTypeFromHint(cls, typeHint: Any) -> bool:
+        """Return whether typeHint accepts int (including ``int | None`` only)."""
+        return cls._scalarTypeFromHint(typeHint, int)
+
+    @classmethod
+    def _tryParseIntFieldValue(
+        cls,
+        field_path: str,
+        fieldName: str,
+        TupleClass: Type[Tuple],
+        typeHint: Any,
+        value: Any,
+    ) -> tuple[Any, TupleValidationError | None]:
+        """Parse JSON float tokens as ``int`` when the field type is ``int``."""
+        if value is None:
+            return value, None
+
+        if not cls._intTypeFromHint(typeHint):
+            return value, None
+
+        if isinstance(value, int) and not isinstance(value, bool):
+            return value, None
+
+        if isinstance(value, float):
+            parsedInt = int(value)
+            if not value.is_integer():
+                logger.warning(
+                    "At %s: parsing %s field %s lost precision converting "
+                    "float %r to int %s",
+                    field_path,
+                    TupleClass.__name__,
+                    fieldName,
+                    value,
+                    parsedInt,
+                )
+            return parsedInt, None
+
+        return value, None
+
     @classmethod
     def _nestedTupleTypeFromHint(cls, typeHint: Any) -> Any | None:
         """Return nested tuple class for a field hint, including ``X | None`` unions."""
@@ -413,6 +500,26 @@ class TupleDocumentConverterBase:
                 if enumError:
                     errors.append(enumError)
                     continue
+                item, floatError = cls._tryParseFloatFieldValue(
+                    item_path,
+                    fieldName,
+                    TupleClass,
+                    listItemTypeHint,
+                    item,
+                )
+                if floatError:
+                    errors.append(floatError)
+                    continue
+                item, intError = cls._tryParseIntFieldValue(
+                    item_path,
+                    fieldName,
+                    TupleClass,
+                    listItemTypeHint,
+                    item,
+                )
+                if intError:
+                    errors.append(intError)
+                    continue
                 itemError = cls._checkType(
                     TupleClass,
                     item_path,
@@ -578,6 +685,20 @@ class TupleDocumentConverterBase:
             errors.append(enumError)
             return _ConvertResult(_UNSET, errors)
 
+        value, floatError = cls._tryParseFloatFieldValue(
+            field_path, fieldName, TupleClass, typeHint, value
+        )
+        if floatError:
+            errors.append(floatError)
+            return _ConvertResult(_UNSET, errors)
+
+        value, intError = cls._tryParseIntFieldValue(
+            field_path, fieldName, TupleClass, typeHint, value
+        )
+        if intError:
+            errors.append(intError)
+            return _ConvertResult(_UNSET, errors)
+
         typeError = cls._checkType(
             TupleClass, field_path, fieldName, typeHint, value, validator
         )

{vortexpy-4.3.4 → vortexpy-4.3.5}/vortex/TupleRestful_test.py

@@ -3,6 +3,7 @@
 
 import json
 from datetime import UTC, datetime
+from unittest.mock import patch
 
 from ddt import data, ddt
 import unittest
@@ -102,6 +103,40 @@ class TupleRestfulTest(unittest.TestCase):
         self.assertNotIn("aBoolFalse", jsonDict)
         self.assertIn("aBoolTrue", jsonDict)
 
+    def testRestfulIntegerJsonParsesAsFloatField(self) -> None:
+        jsonDict = _validRestfulJsonDict()
+        jsonDict["aFloat"] = 151
+        deserialisedTuple = Tuple.restfulJsonDictToTupleWithValidation(
+            jsonDict, RestfulTestTuple
+        )
+        self.assertEqual(deserialisedTuple.aFloat, 151.0)
+
+    def testRestfulWholeFloatJsonParsesAsIntField(self) -> None:
+        jsonDict = _validRestfulJsonDict()
+        jsonDict["aInt"] = 151.0
+        with patch(
+            "vortex.TupleDocumentConverter.logger.warning"
+        ) as mockWarning:
+            deserialisedTuple = Tuple.restfulJsonDictToTupleWithValidation(
+                jsonDict, RestfulTestTuple
+            )
+        self.assertEqual(deserialisedTuple.aInt, 151)
+        mockWarning.assert_not_called()
+
+    def testRestfulFractionalFloatJsonParsesAsIntFieldWithWarning(self) -> None:
+        jsonDict = _validRestfulJsonDict()
+        jsonDict["aInt"] = 151.7
+        with patch(
+            "vortex.TupleDocumentConverter.logger.warning"
+        ) as mockWarning:
+            deserialisedTuple = Tuple.restfulJsonDictToTupleWithValidation(
+                jsonDict, RestfulTestTuple
+            )
+        self.assertEqual(deserialisedTuple.aInt, 151)
+        mockWarning.assert_called_once()
+        warningMessage = mockWarning.call_args[0][0]
+        self.assertIn("lost precision", warningMessage)
+
     def testRestfulConverterClassMethodsMatchTupleDelegates(self) -> None:
         origTuple = makeRestfulTestTuple()
         viaTuple = origTuple.tupleToRestfulJsonDict()

{vortexpy-4.3.4 → vortexpy-4.3.5}/vortex/__init__.py

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

{vortexpy-4.3.4 → vortexpy-4.3.5}/vortex/handler/TupleDataObservableProxyHandler.py

@@ -174,6 +174,7 @@ class TupleDataObservableProxyHandler(TupleDataObservableCache):
                     payloadEnvelope,
                     vortexUuid,
                     sendResponse,
+                    vortexName,
                     vortexSession=vortexSession,
                 )
                 if d:
@@ -186,6 +187,7 @@ class TupleDataObservableProxyHandler(TupleDataObservableCache):
                 payloadEnvelope,
                 vortexUuid,
                 sendResponse,
+                vortexName,
                 vortexSession=vortexSession,
             )
             if d:
@@ -199,6 +201,7 @@ class TupleDataObservableProxyHandler(TupleDataObservableCache):
         payloadEnvelope: PayloadEnvelope,
         vortexUuid: str,
         sendResponse: SendVortexMsgResponseCallable,
+        vortexName: str,
         vortexSession=None,
     ):
 
@@ -210,6 +213,7 @@ class TupleDataObservableProxyHandler(TupleDataObservableCache):
                 payloadEnvelope=payloadEnvelope,
                 vortexUuid=vortexUuid,
                 sendResponse=sendResponse,
+                vortexName=vortexName,
                 vortexSession=vortexSession,
             )
 

{vortexpy-4.3.4 → vortexpy-4.3.5}/vortex/tuple_test_fixtures.py

@@ -149,6 +149,14 @@ class BsonEnumTestTuple(Tuple):
     priorities: List[BsonPriorityE] = TupleField()
 
 
+@addTupleType
+class BsonOptionalFloatTestTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.BsonOptionalFloatTestTuple"
+
+    requiredFloat: float = TupleField()
+    optionalFloat: float | None = TupleField()
+
+
 @addTupleType
 class BsonOptionalDatetimeTestTuple(Tuple):
     __tupleType__ = "flyingion.vortex.BsonOptionalDatetimeTestTuple"

{vortexpy-4.3.4 → vortexpy-4.3.5}/vortexpy.egg-info/PKG-INFO

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