vortexpy 4.3.3__tar.gz → 4.3.5__tar.gz

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

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

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

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

{vortexpy-4.3.3 → vortexpy-4.3.5}/vortex/handler/TupleActionProcessor.py

@@ -188,7 +188,10 @@ class TupleActionProcessor:
         return tupleName in self._tupleProcessorsByTupleName
 
     def shutdown(self):
-        self._endpoint.shutdown()
+        endpoint = getattr(self, "_endpoint", None)
+        if endpoint is not None:
+            endpoint.shutdown()
+            self._endpoint = None
 
     def _denyDelegate(
         self, log_fn, log_msg, error_msg, filt, tupleName, sendResponse

{vortexpy-4.3.3 → vortexpy-4.3.5}/vortex/handler/TupleDataAccessGranterABC.py

@@ -17,16 +17,16 @@ from vortex.VortexAccessControlContextABC import VortexAccessControlContextABC
 
 
 class TupleDataAccessGranterABC(ABC):
-    """Abstract base class for per-observer Level 2 push access control.
+    """Abstract base class for per-observer Level 2 tuple data access control.
 
     Register a concrete implementation via
     :meth:`~vortex.handler.TupleDataObservableHandler.TupleDataObservableHandler.addTupleProvider`
     (``accessGranter=`` parameter) or via
     :meth:`~vortex.handler.TupleDataObservableProxyHandler.TupleDataObservableProxyHandler.addTupleAccessGranter`.
 
-    Called for each subscribed observer before a server-push update is sent.
-    Return ``True`` (or a Deferred that fires with ``True``) to allow delivery,
-    ``False`` to silently skip that observer.
+    Called before a client subscribes (initial response) and for each subscribed
+    observer before a server-push update is sent.  Return ``True`` (or a Deferred
+    that fires with ``True``) to allow delivery, ``False`` to deny that observer.
     """
 
     @abstractmethod

{vortexpy-4.3.3 → vortexpy-4.3.5}/vortex/handler/TupleDataObservableHandler.py

@@ -28,14 +28,12 @@ from vortex.PayloadEndpoint import PayloadEndpoint
 from vortex.PayloadEnvelope import PayloadEnvelope
 from vortex.TupleSelector import TupleSelector
 from vortex.VortexABC import SendVortexMsgResponseCallable
+from vortex.VortexAccessControlContextABC import NO_AUTH_ACCESS_CONTROL_CONTEXT
 from vortex.VortexFactory import VortexFactory
 from twisted.internet.defer import maybeDeferred as _maybeDeferred
 
 from vortex.handler.TupleDataProviderABC import TupleDataProviderABC
 from vortex.handler.TupleDataAccessGranterABC import TupleDataAccessGranterABC
-from vortex.VortexEndpointPermission import (
-    EndpointPermissionsType as PermissionsType,
-)
 from vortex.VortexSession import checkNoHttpSessionInSignature
 from vortex.VortexUtil import limitConcurrency, _dedupProcessorCallKeys
 
@@ -65,9 +63,7 @@ class TupleSelectorUpdateMapperABC(metaclass=ABCMeta):
         """
 
 
-_ObserverDetails = namedtuple(
-    "_ObserverDetails", ["vortexUuid", "observerName"]
-)
+_ObserverDetails = namedtuple("_ObserverDetails", ["vortexUuid", "observerName"])
 
 
 class _ObserverData:
@@ -114,9 +110,7 @@ class TupleDataObservableHandler:
         self._observerDataByTupleSelector = {}
 
         self._tupleProvidersByTupleName = {}
-        self._accessGrantersByTupleName: Dict[
-            str, TupleDataAccessGranterABC
-        ] = {}
+        self._accessGrantersByTupleName: Dict[str, TupleDataAccessGranterABC] = {}
         self._tupleSelectorUpdateMappers = []
 
     def addTupleProvider(
@@ -126,7 +120,7 @@ class TupleDataObservableHandler:
         accessGranter: Optional[TupleDataAccessGranterABC] = None,
     ):
         """Add Tuple Provider"""
-        assert not tupleName in self._tupleProvidersByTupleName, (
+        assert tupleName not in self._tupleProvidersByTupleName, (
             "Observable:%s, Tuple name %s is already registered"
             % (
                 self._observableName,
@@ -150,16 +144,13 @@ class TupleDataObservableHandler:
             self._accessGrantersByTupleName[tupleName] = accessGranter
 
         providerDesc = (
-            f"{type(provider).__module__}."
-            f"{type(provider).__qualname__}.makeVortexMsg"
+            f"{type(provider).__module__}.{type(provider).__qualname__}.makeVortexMsg"
         )
         checkNoHttpSessionInSignature(provider.makeVortexMsg, providerDesc)
 
         self._tupleProvidersByTupleName[tupleName] = provider
 
-    def addTupleSelectorUpdateMapper(
-        self, mapper: TupleSelectorUpdateMapperABC
-    ):
+    def addTupleSelectorUpdateMapper(self, mapper: TupleSelectorUpdateMapperABC):
         """Add Tuple Selector Update Mapper
 
         This mapper will be called every time a tuple selector is notified of an update.
@@ -180,9 +171,7 @@ class TupleDataObservableHandler:
             for jsonStr in self._observerDataByTupleSelector
         ]
 
-    def tupleSubscriberCount(
-        self, tupleNames: Optional[frozenset[str]] = None
-    ) -> int:
+    def tupleSubscriberCount(self, tupleNames: Optional[frozenset[str]] = None) -> int:
         subscriberVortexUuids: set[str] = set()
         for observerData in self._observerDataByTupleSelector.values():
             if (
@@ -255,9 +244,7 @@ class TupleDataObservableHandler:
         if d:
             d.addErrback(vortexLogFailure, logger, consumeError=True)
 
-    @limitConcurrency(
-        logger, 25, deduplicateBasedOnKwArgsKey=_dedupProcessorCallKeys
-    )
+    @limitConcurrency(logger, 25, deduplicateBasedOnKwArgsKey=_dedupProcessorCallKeys)
     def _processLimitedDecorated(
         self,
         payloadEnvelope: PayloadEnvelope,
@@ -286,9 +273,7 @@ class TupleDataObservableHandler:
         _ = vortexName
 
         if not VortexFactory.isVortexUuidOnline(vortexUuid):
-            logger.debug(
-                "Vortex %s is no longer online, skipping reply", vortexUuid
-            )
+            logger.debug("Vortex %s is no longer online, skipping reply", vortexUuid)
             return
 
         # logger.debug(
@@ -319,12 +304,8 @@ class TupleDataObservableHandler:
                     tupleSelector.name,
                 )
                 return
-            endpointPermissions = yield _maybeDeferred(
-                auth.getEndpointPermissions, vs
-            )
-            if not tupleProvider.requiredPermissions.issubset(
-                endpointPermissions
-            ):
+            endpointPermissions = yield _maybeDeferred(auth.getEndpointPermissions, vs)
+            if not tupleProvider.requiredPermissions.issubset(endpointPermissions):
                 logger.warning(
                     "Observable:%s permission denied for %s",
                     self._observableName,
@@ -360,18 +341,50 @@ class TupleDataObservableHandler:
 
             return
 
+        granter = self._accessGrantersByTupleName.get(tupleSelector.name)
+        if granter:
+            filt = dict(tupleSelector=tupleSelector)
+            filt.update(self._filt)
+            auth = VortexFactory.getAuthenticator()
+            ctx = NO_AUTH_ACCESS_CONTROL_CONTEXT
+            if auth:
+                if not vs:
+                    logger.warning(
+                        "Observable:%s access denied for %s:"
+                        " no VortexSession for access control context.",
+                        self._observableName,
+                        tupleSelector.name,
+                    )
+                    return
+                ctx = yield _maybeDeferred(
+                    auth.getAccessControlContext,
+                    vs,
+                    vs.vortexName,
+                    vortexUuid,
+                )
+                if ctx is None:
+                    logger.warning(
+                        "Observable:%s access denied for %s:"
+                        " access control context unavailable.",
+                        self._observableName,
+                        tupleSelector.name,
+                    )
+                    return
+            granted = yield granter.isAccessGranted(filt, tupleSelector, ctx)
+            if not granted:
+                logger.warning(
+                    "Observable:%s access denied for %s",
+                    self._observableName,
+                    tupleSelector.name,
+                )
+                return
+
         # Add support for just getting data, no subscription.
-        if self._subscriptionsEnabled and payloadEnvelope.filt.get(
-            "subscribe", True
-        ):
+        if self._subscriptionsEnabled and payloadEnvelope.filt.get("subscribe", True):
             if tsStr not in self._observerDataByTupleSelector:
-                self._observerDataByTupleSelector[tsStr] = _ObserverData(
-                    tupleSelector
-                )
+                self._observerDataByTupleSelector[tsStr] = _ObserverData(tupleSelector)
 
-            self._observerDataByTupleSelector[tsStr].observers.add(
-                observerDetails
-            )
+            self._observerDataByTupleSelector[tsStr].observers.add(observerDetails)
             self._observerDataByTupleSelector[tsStr].vortexSessionByVortexUuid[
                 vortexUuid
             ] = vs
@@ -395,8 +408,7 @@ class TupleDataObservableHandler:
     ) -> List[TupleSelector]:
         # Get all tuple selectors
         allTupleSelectors = [
-            data.tupleSelector
-            for data in self._observerDataByTupleSelector.values()
+            data.tupleSelector for data in self._observerDataByTupleSelector.values()
         ]
 
         # Create a dict so we end up with only unique ones
@@ -404,9 +416,7 @@ class TupleDataObservableHandler:
 
         # Run through the mappers
         for mapper in self._tupleSelectorUpdateMappers:
-            mappedSelectors = mapper.mapTupleSelector(
-                tupleSelector, allTupleSelectors
-            )
+            mappedSelectors = mapper.mapTupleSelector(tupleSelector, allTupleSelectors)
             if mappedSelectors:
                 tupleSelectorByStr.update(
                     {ts.toJsonStr(): ts for ts in mappedSelectors}
@@ -498,9 +508,7 @@ class TupleDataObservableHandler:
         # Send the vortex messages, checking access per observer if a granter is set
         for destVortexUuid in destVortexUuids:
             if granter:
-                sessionVs = observerData.vortexSessionByVortexUuid.get(
-                    destVortexUuid
-                )
+                sessionVs = observerData.vortexSessionByVortexUuid.get(destVortexUuid)
                 ctx = None
                 if auth and sessionVs:
                     ctx = yield _maybeDeferred(
@@ -509,8 +517,8 @@ class TupleDataObservableHandler:
                         sessionVs.vortexName,
                         destVortexUuid,
                     )
-                granted = yield _maybeDeferred(
-                    granter.isAccessGranted, filt, tupleSelector, ctx
+                granted = yield granter.isAccessGranted(
+                    filt, tupleSelector, ctx
                 )
                 if not granted:
                     continue