vortexpy 4.1.2__tar.gz → 4.1.5__tar.gz

{vortexpy-4.1.2 → vortexpy-4.1.5}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.1.2"
+version = "4.1.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.1.2 → vortexpy-4.1.5}/vortex/DeferUtil.py

@@ -175,9 +175,7 @@ def deferToThreadWrapWithLogger(
 
 
     """
-    assert isinstance(
-        loggerArg, logging.Logger
-    ), """Usage:
+    assert isinstance(loggerArg, logging.Logger), """Usage:
     import logging
     logger = logging.getLogger(__name__)
     @deferToThreadWrapWithLogger(logger)

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/PayloadEndpoint.py

@@ -22,7 +22,9 @@ from vortex.VortexAccessControlContextABC import (
     NO_AUTH_ACCESS_CONTROL_CONTEXT,
     VortexAccessControlContextABC,
 )
-from vortex.VortexEndpointPermission import EndpointPermissionsType as PermissionsType
+from vortex.VortexEndpointPermission import (
+    EndpointPermissionsType as PermissionsType,
+)
 from vortex.VortexSession import (
     _callableLabel,
     checkAccessControlContextSignature,
@@ -81,7 +83,9 @@ class PayloadEndpoint:
             explicitly declare "no permissions required".  Omitting the
             parameter (``None``) emits a deprecation warning.
         """
-        self._requiredPermissions: Optional[PermissionsType] = requiredPermissions
+        self._requiredPermissions: Optional[PermissionsType] = (
+            requiredPermissions
+        )
 
         if requiredPermissions is None:
             logger.warning(self._NO_PERMISSIONS_WARNING, filt)
@@ -89,9 +93,11 @@ class PayloadEndpoint:
         callableDesc = (
             f"PayloadEndpoint filt={filt} callback={_callableLabel(callable_)}"
         )
-        self._callableAcceptsAccessControlContext = checkAccessControlContextSignature(
-            callable_,
-            callableDescription=callableDesc,
+        self._callableAcceptsAccessControlContext = (
+            checkAccessControlContextSignature(
+                callable_,
+                callableDescription=callableDesc,
+            )
         )
         checkNoHttpSessionInSignature(callable_, callableDesc)
 
@@ -168,7 +174,10 @@ class PayloadEndpoint:
             return False
 
         # Filter for the backend vortexes.
-        if self._acceptOnlyFromVortex and vortexName not in self._acceptOnlyFromVortex:
+        if (
+            self._acceptOnlyFromVortex
+            and vortexName not in self._acceptOnlyFromVortex
+        ):
             return False
 
         def removeUnhashable(filt):
@@ -212,7 +221,9 @@ class PayloadEndpoint:
         if not self.check(payloadEnvelope, vortexName):
             return
 
-        if self.PERMITTER and not self.PERMITTER.check(payloadEnvelope, vortexSession):
+        if self.PERMITTER and not self.PERMITTER.check(
+            payloadEnvelope, vortexSession
+        ):
             logger.debug("Permission failed for %s", payloadEnvelope.filt)
             return
 
@@ -250,7 +261,10 @@ class PayloadEndpoint:
         accessControlContext = NO_AUTH_ACCESS_CONTROL_CONTEXT
         if self._callableAcceptsAccessControlContext and auth and vortexSession:
             raw_ctx = yield maybeDeferred(
-                auth.getAccessControlContext, vortexSession, vortexName, vortexUuid
+                auth.getAccessControlContext,
+                vortexSession,
+                vortexName,
+                vortexUuid,
             )
             if not isinstance(raw_ctx, VortexAccessControlContextABC):
                 logger.error(

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/PayloadEndpointTest.py

@@ -143,9 +143,7 @@ class PayloadEndpointPyTest(unittest.TestCase):
 
         def subScope():
             inst = PayloadEndpointPyTestAssignPayload(self)
-            PayloadEndpoint(
-                filt, inst.process, requiredPermissions=frozenset()
-            )
+            PayloadEndpoint(filt, inst.process, requiredPermissions=frozenset())
 
         self._processEnvelope(payload)
         yield self._flushReactor()

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/PayloadEnvelope.py

@@ -57,9 +57,9 @@ class PayloadEnvelope(Jsonable):
     ) -> None:
         Jsonable.__init__(self)
         """Constructor"""
-        assert not (
-            data and encodedPayload
-        ), "You can not pass encodedData and encodedPayload"
+        assert not (data and encodedPayload), (
+            "You can not pass encodedData and encodedPayload"
+        )
 
         self.filt: Dict = {} if filt is None else filt
         self.data: Union[Any, str, None] = data if data else encodedPayload
@@ -75,18 +75,18 @@ class PayloadEnvelope(Jsonable):
     @property
     def encodedPayload(self) -> Optional[str]:
         # self.data could be from VortexJS/Typescript where we allow `str` data
-        assert self.data is None or isinstance(
-            self.data, str
-        ), "Encoded payload is not None or a string"
+        assert self.data is None or isinstance(self.data, str), (
+            "Encoded payload is not None or a string"
+        )
         return self.data
 
     @encodedPayload.setter
     def encodedPayload(self, val: Optional[str]):
         # This value should only be set from users of VortexPy and
         # Payload.toEncodedPayload so we only allow str or None
-        assert val is None or isinstance(
-            val, str
-        ), "Encoded payload is not None or a string"
+        assert val is None or isinstance(val, str), (
+            "Encoded payload is not None or a string"
+        )
         self.data = val
 
     def isEmpty(self):

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/SerialiseUtil.py

@@ -7,6 +7,7 @@
 # Support : contact@flyingion.com
 
 import decimal
+import enum
 import logging
 from base64 import b64encode, b64decode
 from collections import defaultdict
@@ -267,6 +268,12 @@ def toRapuiType(value):
     if isinstance(value, PayloadEnvelope):
         return T_RAPUI_PAYLOAD_ENVELOPE
 
+    if isinstance(value, enum.StrEnum):
+        return T_STR
+
+    if isinstance(value, enum.IntEnum):
+        return T_INT
+
     valueClass = value.__class__
 
     return TYPE_MAP_PY_TO_RAPUI[valueClass]

vortexpy-4.1.5/vortex/SerialiseUtil_test.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+#
+# This software is open source; the MIT license applies.
+# See LICENSE for the full license text.
+#
+# Website : https://flyingion.com
+# Support : contact@flyingion.com
+
+import json
+from enum import Enum, IntEnum, StrEnum
+
+from twisted.trial import unittest
+
+from vortex.SerialiseUtil import T_INT, T_STR, fromStr, toRapuiType, toStr
+from vortex.TupleSelector import TupleSelector
+
+
+class SampleStrEnumE(StrEnum):
+    CrewDatum = "crew-datum"
+    ViewJobDetail = "view-job-detail-datum"
+
+
+class SampleIntEnumE(IntEnum):
+    One = 1
+    Two = 2
+
+
+class SamplePlainEnumE(Enum):
+    Alpha = "alpha"
+
+
+class SerialiseUtilTest(unittest.TestCase):
+    def testToRapuiTypeStrEnumMember(self) -> None:
+        self.assertEqual(toRapuiType(SampleStrEnumE.CrewDatum), T_STR)
+        self.assertEqual(
+            toRapuiType(SampleStrEnumE.ViewJobDetail),
+            T_STR,
+        )
+
+    def testToRapuiTypeIntEnumMember(self) -> None:
+        self.assertEqual(toRapuiType(SampleIntEnumE.One), T_INT)
+        self.assertEqual(toRapuiType(SampleIntEnumE.Two), T_INT)
+
+    def testToRapuiTypePlainEnumMemberRaises(self) -> None:
+        with self.assertRaises(KeyError):
+            toRapuiType(SamplePlainEnumE.Alpha)
+
+    def testToStrStrEnumMember(self) -> None:
+        self.assertEqual(toStr(SampleStrEnumE.CrewDatum), "crew-datum")
+
+    def testFromStrRoundTripStrEnumWireValue(self) -> None:
+        wireValue = toStr(SampleStrEnumE.CrewDatum)
+        self.assertEqual(fromStr(wireValue, T_STR), "crew-datum")
+
+    def testTupleSelectorSerialisesStrEnumSelectorValues(self) -> None:
+        selector = TupleSelector(
+            "peek_core_datum.DatumMappingTuple",
+            dict(
+                sourcePlugin="peek_plugin_switching_viewer",
+                datumPendingKey=SampleStrEnumE.CrewDatum,
+            ),
+        )
+        jsonStr = selector.toJsonStr()
+        parsed = json.loads(jsonStr)
+        self.assertEqual(
+            parsed["selector"]["datumPendingKey"],
+            "crew-datum",
+        )
+        self.assertEqual(parsed["selector"]["sourcePlugin"], "peek_plugin_switching_viewer")
+
+    def testTupleSelectorStrEnumRoundTrip(self) -> None:
+        original = TupleSelector(
+            "peek_core_datum.DatumMappingTuple",
+            dict(
+                sourcePlugin="peek_plugin_switching_viewer",
+                datumPendingKey=SampleStrEnumE.ViewJobDetail,
+            ),
+        )
+        restored = TupleSelector.fromJsonStr(original.toJsonStr())
+        self.assertEqual(restored.name, original.name)
+        self.assertEqual(
+            restored.selector["datumPendingKey"],
+            "view-job-detail-datum",
+        )
+        self.assertIsInstance(restored.selector["datumPendingKey"], str)
+
+    def testTupleSelectorSerialisesIntEnumSelectorValues(self) -> None:
+        selector = TupleSelector(
+            "test.ExampleTuple",
+            dict(priority=SampleIntEnumE.Two),
+        )
+        jsonStr = selector.toJsonStr()
+        parsed = json.loads(jsonStr)
+        self.assertEqual(
+            parsed["selector"]["priority"],
+            {"_fd": 2, "_ft": "int"},
+        )
+
+    def testTupleSelectorIntEnumRoundTrip(self) -> None:
+        original = TupleSelector(
+            "test.ExampleTuple",
+            dict(priority=SampleIntEnumE.One),
+        )
+        restored = TupleSelector.fromJsonStr(original.toJsonStr())
+        self.assertEqual(restored.selector["priority"], 1)
+        self.assertIsInstance(restored.selector["priority"], int)

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/Tuple.py

@@ -354,13 +354,12 @@ class IntTupleFieldValidator(TupleFieldValidatorABC):
     def validate(self, fieldName: str, value):
         if self._low is not None and value < self._low:
             raise ValueError(
-                f"Field {fieldName}," f" Value {value} is less than {self._low}"
+                f"Field {fieldName}, Value {value} is less than {self._low}"
             )
 
         if self._high is not None and self._high < value:
             raise ValueError(
-                f"Field {fieldName},"
-                f" Value {value} is greater than {self._high}"
+                f"Field {fieldName}, Value {value} is greater than {self._high}"
             )
 
 

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/TuplePolymorphicTupleTypeFieldArgTest.py

@@ -98,5 +98,8 @@ class PolymorphicTupleTypeFieldArgTest(unittest.TestCase):
             any(err.field_path == "concreteType" for err in result.errors)
         )
         self.assertTrue(
-            any(err.message.startswith("At concreteType:") for err in result.errors)
+            any(
+                err.message.startswith("At concreteType:")
+                for err in result.errors
+            )
         )

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/TupleRestful.py

@@ -160,12 +160,16 @@ class TupleRestfulConverter:
                 return [convert(item) for item in value]
 
             if isinstance(value, dict):
-                return {convert(key): convert(item) for key, item in value.items()}
+                return {
+                    convert(key): convert(item) for key, item in value.items()
+                }
 
             from .Tuple import Tuple
 
             if isinstance(value, Tuple):
-                return cls.tupleToRestfulJsonDict(value, includeNones, includeFalse)
+                return cls.tupleToRestfulJsonDict(
+                    value, includeNones, includeFalse
+                )
 
             if isinstance(value, WKBElement):
                 return convertFromWkbElement(value)
@@ -202,7 +206,10 @@ class TupleRestfulConverter:
                 else prefix
             )
             detail = validationError.message
-            if validationError.message.startswith("At ") and ": " in validationError.message:
+            if (
+                validationError.message.startswith("At ")
+                and ": " in validationError.message
+            ):
                 detail = validationError.message.split(": ", 1)[1]
             prefixed.append(
                 cls._makeError(field_path, detail, validationError.exc_type)
@@ -334,8 +341,12 @@ class TupleRestfulConverter:
     ) -> _ConvertResult:
         errors: list[TupleValidationError] = []
         listItemTypeHint = get_args(typeHint)[0]
-        listItemExtraHint = get_args(extraTypeHint)[0] if extraTypeHint else None
-        listItemTypeValidator = cls._getFieldValidatorFromExtraHint(listItemExtraHint)
+        listItemExtraHint = (
+            get_args(extraTypeHint)[0] if extraTypeHint else None
+        )
+        listItemTypeValidator = cls._getFieldValidatorFromExtraHint(
+            listItemExtraHint
+        )
         data: list[Any] = []
 
         if hasattr(listItemTypeHint, "__tupleType__"):
@@ -356,7 +367,9 @@ class TupleRestfulConverter:
                     item, listItemTypeHint
                 )
                 data.append(child.tuple_)
-                errors.extend(cls._prefixValidationErrors(child.errors, item_path))
+                errors.extend(
+                    cls._prefixValidationErrors(child.errors, item_path)
+                )
         else:
             for index, item in enumerate(value):
                 item_path = f"{field_path}[{index}]"
@@ -440,7 +453,9 @@ class TupleRestfulConverter:
         typeHint: Any,
     ) -> _ConvertResult:
         if hasattr(typeHint, "__tupleType__"):
-            child = cls.restfulJsonDictToTupleWithValidationResult(value, typeHint)
+            child = cls.restfulJsonDictToTupleWithValidationResult(
+                value, typeHint
+            )
             return _ConvertResult(
                 child.tuple_,
                 cls._prefixValidationErrors(child.errors, field_path),
@@ -587,7 +602,9 @@ class TupleRestfulConverter:
     def restfulJsonDictToTupleWithValidation(
         cls, jsonDict: dict[str, Any], TupleClass: Type[Tuple]
     ) -> Tuple:
-        result = cls.restfulJsonDictToTupleWithValidationResult(jsonDict, TupleClass)
+        result = cls.restfulJsonDictToTupleWithValidationResult(
+            jsonDict, TupleClass
+        )
         if result.errors:
             firstValidationError = result.errors[0]
             raise firstValidationError.exc_type(firstValidationError.message)

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/TupleRestfulTest.py

@@ -30,9 +30,9 @@ class RestfulTestTuple(Tuple):
 
     __tupleType__ = "flyingion.vortex.RestfulTestTuple"
     aInt: int = TupleField()
-    aIntWithValidator: Annotated[
-        int, IntTupleFieldValidator(1, 100)
-    ] = TupleField()
+    aIntWithValidator: Annotated[int, IntTupleFieldValidator(1, 100)] = (
+        TupleField()
+    )
     aFloat: float = TupleField()
     aString: str = TupleField()
     aBoolTrue: bool = TupleField()
@@ -150,8 +150,12 @@ class TupleRestfulTest(unittest.TestCase):
     def testOptionalDatetimeRoundTrip(self):
         utc = pytz.UTC
         origTuple = RestfulOptionalDatetimeTestTuple()
-        origTuple.requiredDate = datetime(2024, 6, 15, 10, 30, 45, 123456, tzinfo=utc)
-        origTuple.optionalDate = datetime(2024, 6, 16, 11, 31, 46, 654321, tzinfo=utc)
+        origTuple.requiredDate = datetime(
+            2024, 6, 15, 10, 30, 45, 123456, tzinfo=utc
+        )
+        origTuple.optionalDate = datetime(
+            2024, 6, 16, 11, 31, 46, 654321, tzinfo=utc
+        )
 
         jsonDict = origTuple.tupleToRestfulJsonDict()
         jsonDict = json.loads(json.dumps(jsonDict))
@@ -250,7 +254,9 @@ class TupleRestfulCollectingTest(unittest.TestCase):
         self.assertIsNone(result.tuple_.aSubTuple.subInt)
         self.assertEqual(len(result.errors), 1)
         self.assertEqual(result.errors[0].field_path, "aSubTuple.subInt")
-        self.assertTrue(result.errors[0].message.startswith("At aSubTuple.subInt:"))
+        self.assertTrue(
+            result.errors[0].message.startswith("At aSubTuple.subInt:")
+        )
 
     def testStrictWrapperRaisesFirstCollectingError(self):
         jsonDict = _validRestfulJsonDict()
@@ -262,6 +268,8 @@ class TupleRestfulCollectingTest(unittest.TestCase):
         )
 
         with self.assertRaises(result.errors[0].exc_type) as ctx:
-            Tuple.restfulJsonDictToTupleWithValidation(jsonDict, RestfulTestTuple)
+            Tuple.restfulJsonDictToTupleWithValidation(
+                jsonDict, RestfulTestTuple
+            )
 
         self.assertEqual(str(ctx.exception), result.errors[0].message)

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexAccessControlContextABC.py

@@ -6,6 +6,7 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
+
 class VortexAccessControlContextABC:
     """Abstract base class for application-level access control contexts.
 

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexFactory.py

@@ -75,7 +75,7 @@ class _VortexConnectionRateLimit:
     def __init__(self):
         self._connections: list[_ConnectionDateSuccess] = []
         self._peerConnectionLimitPerIp = None
-        self._newConnectionsPerWindow = 5
+        self._newConnectionsPerWindow = 20
         self._rollingNewConnectionWindowSeconds = 10.0
 
     def _hasHitPeerConnectionLimit(
@@ -109,8 +109,10 @@ class _VortexConnectionRateLimit:
         now = datetime.now(pytz.utc)
         self._connections = list(
             filter(
-                lambda item: (now - item.dateTime).total_seconds()
-                < self._rollingNewConnectionWindowSeconds,
+                lambda item: (
+                    (now - item.dateTime).total_seconds()
+                    < self._rollingNewConnectionWindowSeconds
+                ),
                 self._connections,
             )
         )
@@ -355,7 +357,8 @@ class _VortexFactoryVortexInfo:
     def getRemoteClientVortexInfos(self) -> List[VortexInfo]:
         return [
             VortexInfo(name=name, uuid=uuid)
-            for name, (vortex, uuid) in self.__remoteVortexUuidsByName.items()
+            for name, infos in self.__remoteVortexUuidsByName.items()
+            for _vortex, uuid in infos
         ]
 
     @property
@@ -794,6 +797,12 @@ class VortexFactory:
     def getRemoteClientVortexInfos(cls) -> List[VortexInfo]:
         return cls.__vortexInfoState.getRemoteClientVortexInfos
 
+    @classmethod
+    def getRemoteVortexInfos(
+        cls, name=None, uuid=None
+    ) -> list[tuple[VortexABC, str]]:
+        return cls.__vortexInfoState.getRemoteVortexInfos(name=name, uuid=uuid)
+
     @classmethod
     def getRemoteVortexUuids(cls) -> set[str]:
         return cls.__vortexInfoState.getRemoteVortexUuids

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexPayloadProtocol.py

@@ -97,7 +97,9 @@ class VortexPayloadProtocol(Protocol, metaclass=ABCMeta):
             )
 
         elif isinstance(reasonFailure.value, ConnectionLost):
-            self._logger.info("Connection to other end lost (We may be shutting down)")
+            self._logger.info(
+                "Connection to other end lost (We may be shutting down)"
+            )
 
         else:
             self._logger.error("Closed with error")
@@ -135,7 +137,9 @@ class VortexPayloadProtocol(Protocol, metaclass=ABCMeta):
             vortexMsg = self._vortexMsgsQueue.popleft()
 
             try:
-                payloadEnvelope = yield PayloadEnvelope().fromVortexMsgDefer(vortexMsg)
+                payloadEnvelope = yield PayloadEnvelope().fromVortexMsgDefer(
+                    vortexMsg
+                )
 
                 if payloadEnvelope.isEmpty():
                     self._processServerInfoPayload(payloadEnvelope)

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexPermission.py

@@ -7,6 +7,7 @@
 # Support : contact@flyingion.com
 
 """Backward-compatibility shim.  Import from VortexEndpointPermission instead."""
+
 from vortex.VortexEndpointPermission import (  # noqa: F401
     VortexEndpointPermission,
     EndpointPermissionsType,

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexPermissionError.py

@@ -6,6 +6,7 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
+
 class VortexPermissionError(PermissionError):
     """Raised by application code to signal a Level 2 access-control denial.
 

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexServer.py

@@ -43,7 +43,7 @@ VortexServer
 """
 
 HEART_BEAT_PERIOD = 10.0
-HEART_BEAT_TIMEOUT = 180.0
+HEART_BEAT_TIMEOUT = 60.0
 
 
 class VortexServer(VortexABC):
@@ -153,13 +153,15 @@ class VortexServer(VortexABC):
                     lambda: self._sessionExpired(httpSession.uid)
                 )
 
-            # Update the connection dict in the sessions object
             httpSessionConns = VortexSessionI(httpSession).connections
+            for oldConn in list(httpSessionConns.values()):
+                if oldConn is not vortexConnection:
+                    oldConn.close()
             httpSessionConns[vortexUuid] = vortexConnection
 
-        # Get the old connection if it exists
         if vortexUuid in self._connectionByVortexUuid:
-            self._connectionByVortexUuid[vortexUuid].close()
+            if self._connectionByVortexUuid[vortexUuid] is not vortexConnection:
+                self._connectionByVortexUuid[vortexUuid].close()
 
         # Update the _connectionsByvortexUuid
         self._connectionByVortexUuid[vortexUuid] = vortexConnection
@@ -335,7 +337,6 @@ class VortexServer(VortexABC):
 
         for conn in conns:
             for vortexMsg in vortexMsgs:
-
                 # noinspection PyProtectedMember
                 if VortexFactory._DEBUG_LOGGING:
                     logger.debug(

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexServerConnection.py

@@ -73,12 +73,12 @@ class VortexServerConnection(VortexConnectionABC):
 
         beatTimeout = (
             datetime.now(pytz.utc) - self._lastHeartBeatTime
-        ).seconds > HEART_BEAT_TIMEOUT
+        ).total_seconds() > HEART_BEAT_TIMEOUT
 
         # If we've been asleep, then make note of that (VM suspended)
         checkTimout = (
             datetime.now(pytz.utc) - self._lastHeartBeatCheckTime
-        ).seconds > HEART_BEAT_TIMEOUT
+        ).total_seconds() > HEART_BEAT_TIMEOUT
 
         # Mark that we've just checked it
         self._lastHeartBeatCheckTime = datetime.now(pytz.utc)

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexServerWebsocket.py

@@ -267,13 +267,6 @@ class VortexWebSocketUpgradeResource(resource.Resource):
         return b"upgrade" in connection and upgrade == b"websocket"
 
     def _renderGet(self, request):
-        from vortex.VortexFactory import VortexFactory
-
-        if not VortexFactory.canConnect(str(request.client.host)):
-            request.setResponseCode(503)
-            request.setHeader("Retry-After", str(max(10, int(random() * 100))))
-            return b"Rejected due to new connections throttling."
-
         request.setResponseCode(200)
         request.setHeader(b"Content-Type", b"application/json")
         request.setHeader(b"Cache-Control", b"no-store")

{vortexpy-4.1.2 → vortexpy-4.1.5}/vortex/VortexSession.py

@@ -54,7 +54,6 @@ class VortexSession:
         self.vortexName: str = vortexName
 
 
-
 class VortexTcpSession:
     """Minimal Twisted-session-compatible stub for TCP connections.
 
@@ -101,6 +100,7 @@ class VortexTcpSession:
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def extractVortexIp(request) -> str:
     """Return the real client IP from a Twisted HTTP request.
 
@@ -216,5 +216,7 @@ def _callableLabel(callable_) -> str:
         return f"{module}.{callable_.__qualname__}"
     if hasattr(callable_, "__self__") and hasattr(callable_, "__func__"):
         cls = callable_.__self__.__class__
-        return f"{cls.__module__}.{cls.__qualname__}.{callable_.__func__.__name__}"
+        return (
+            f"{cls.__module__}.{cls.__qualname__}.{callable_.__func__.__name__}"
+        )
     return repr(callable_)