vortexpy 4.0.3__tar.gz → 4.0.6__tar.gz

{vortexpy-4.0.3 → vortexpy-4.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vortexpy
-Version: 4.0.3
+Version: 4.0.6
 Summary: Synertys observable, routable, data serialisation and transport code.
 Author-email: Synerty <contact@synerty.com>
 Project-URL: Homepage, https://github.com/Synerty/vortexpy

{vortexpy-4.0.3 → vortexpy-4.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.0.3"
+version = "4.0.6"
 authors = [{name = "Synerty", email = "contact@synerty.com"}]
 description = "Synertys observable, routable, data serialisation and transport code."
 keywords = [

{vortexpy-4.0.3/vortex/test → vortexpy-4.0.6/vortex}/PayloadTest.py

@@ -13,7 +13,7 @@ from twisted.trial import unittest
 from vortex.Payload import Payload
 from vortex.PayloadFilterKeys import rapuiClientEcho
 from vortex.Tuple import TupleHash
-from vortex.test.VortexTcpMemoryLeakPayloadTest import MemoryCheckerTestMixin
+from vortex.VortexTcpMemoryLeakPayloadTest import MemoryCheckerTestMixin
 
 
 def makeTestPayloadA(tupleDataSize=10 * 1024):
@@ -49,21 +49,21 @@ class PayloadPyTest(unittest.TestCase, MemoryCheckerTestMixin):
         self.assertEqual(payload.tuples[0], origPayload.tuples[0])
 
     def testMakeStr_100m_x100(self):
-        self._memCheckFunction(self._makeStr, 1000, 100 * 1024 ** 2)
+        self._memCheckFunction(self._makeStr, 1000, 100 * 1024**2)
 
     def testPayloadToFromEncodedPayload_10k_x1000(self):
         self._memCheckFunction(self._payloadEncodeDecode, 1000, 10 * 1024)
 
     def testPayloadToFromEncodedPayload_100m_x100(self):
-        self._memCheckFunction(self._payloadEncodeDecode, 100, 10 * 1024 ** 2)
+        self._memCheckFunction(self._payloadEncodeDecode, 100, 10 * 1024**2)
 
     def testPayloadToFromEncodedPayload_1m_x1000(self):
-        self._memCheckFunction(self._payloadEncodeDecode, 1000, 1 * 1024 ** 2)
+        self._memCheckFunction(self._payloadEncodeDecode, 1000, 1 * 1024**2)
 
     def testPayloadToFromEncodedPayload10mb(self):
         # Create Payload
         origPayload = makeTestPayloadA()
-        origPayload.tuples = ["1234567890" * 1024 ** 2]
+        origPayload.tuples = ["1234567890" * 1024**2]
 
         encodedPayload = origPayload.toEncodedPayload()
         payload = Payload().fromEncodedPayload(encodedPayload)

{vortexpy-4.0.3/vortex/test → vortexpy-4.0.6/vortex}/TupleDataForTest.py

@@ -6,7 +6,7 @@
  * Website : http://www.synerty.com
  * Support : support@synerty.com
 """
-from vortex.test.TestTuple import TestTuple
+from vortex.TestTuple import TestTuple
 
 
 def makeTestTupleData(count=5):

{vortexpy-4.0.3/vortex/test → vortexpy-4.0.6/vortex}/TupleRestfulTest.py

@@ -7,7 +7,6 @@
  * Support : support@synerty.com
 """
 
-import datetime
 import json
 from typing import Dict, Annotated
 from typing import List
@@ -16,9 +15,9 @@ from typing import Union
 from ddt import data, ddt
 from twisted.trial import unittest
 
-from vortex.Tuple import TUPLE_TYPES_BY_NAME, TupleHash, IntTupleFieldValidator
 from vortex.Tuple import Tuple
 from vortex.Tuple import TupleField
+from vortex.Tuple import TupleHash, IntTupleFieldValidator
 from vortex.Tuple import addTupleType
 
 

{vortexpy-4.0.3 → vortexpy-4.0.6}/vortex/TupleSelector.py

@@ -7,11 +7,15 @@
  * Support : support@synerty.com
 """
 import json
-from typing import Dict, Optional
+from typing import Dict, Optional, Union, Type
 
 from vortex.Tuple import Tuple, addTupleType
 
 
+class InvalidTupleSelectorNameException(Exception):
+    pass
+
+
 @addTupleType
 class TupleSelector(Tuple):
     __tupleType__ = "vortex.TupleSelector"
@@ -21,10 +25,12 @@ class TupleSelector(Tuple):
     # selector: Dict[str, Any] = TupleField(comment="The values to select")
 
     def __init__(
-        self, name: Optional[str] = None, selector: Optional[Dict] = None
+        self,
+        name: Optional[Union[str, Type[Tuple], Tuple]] = None,
+        selector: Optional[Dict] = None,
     ) -> None:
         Tuple.__init__(self)
-        self.name = name
+        self.name = self.nameFromTuple(name)
         self.selector = selector if selector else {}
 
     def __eq__(self, y):
@@ -33,6 +39,43 @@ class TupleSelector(Tuple):
     def __hash__(self):
         return hash(self.toJsonStr())
 
+    # noinspection PyMethodMayBeStatic
+    @classmethod
+    def nameFromTuple(
+        cls, nameOrTuple: Optional[Union[str, Type[Tuple], Tuple]]
+    ) -> Optional[str]:
+        # When the TupleSelector is reconstructed / deserialised, it's constructed with
+        # no arguments
+        if nameOrTuple is None:
+            return None
+
+        if isinstance(nameOrTuple, str):
+            name = nameOrTuple
+
+        elif issubclass(nameOrTuple, Tuple):
+            name = nameOrTuple.tupleType()
+
+        elif isinstance(nameOrTuple, Tuple):
+            name = nameOrTuple.tupleType()
+
+        else:
+            raise Exception(
+                "Argument should be of type Union[str, Type[Tuple], Tuple]"
+            )
+
+        if name == TupleSelector.tupleName():
+            raise InvalidTupleSelectorNameException(
+                "We've found the name of TupleSelector.tupleType(),"
+                "which means we've been passed a TupleSelector."
+            )
+
+        return name
+
+    def isForTuple(
+        self, nameOrTuple: Optional[Union[str, Type[Tuple], Tuple]]
+    ) -> bool:
+        return self.name == self.nameFromTuple(nameOrTuple)
+
     def toJsonStr(self) -> str:
         """To Json Str
 

{vortexpy-4.0.3/vortex/test → vortexpy-4.0.6/vortex}/TupleTest.py

@@ -12,8 +12,8 @@ import json
 
 from twisted.trial import unittest
 
-from vortex.Tuple import TUPLE_TYPES_BY_NAME, TupleHash
-from vortex.test.TestTuple import TestSubTuple, TestTuple
+from vortex.TestTuple import TestSubTuple, TestTuple
+from vortex.Tuple import TupleHash
 
 
 def makeTupleA():

{vortexpy-4.0.3 → vortexpy-4.0.6}/vortex/VortexFactory.py

@@ -19,13 +19,13 @@ from twisted.internet.defer import inlineCallbacks
 from twisted.internet.defer import succeed
 from twisted.internet.task import deferLater
 from twisted.python.failure import Failure
-
 from txhttputil.util.PemUtil import parsePemBundleForClient
 from txhttputil.util.PemUtil import parsePemBundleForServer
 from txhttputil.util.PemUtil import parsePemBundleForTrustedPeers
 from txhttputil.util.SslUtil import buildCertificateOptionsForTwisted
 from txhttputil.util.SslUtil import parseTrustRootFromBundle
 from txwebsocket.txws import WebSocketFactory
+
 from vortex.DeferUtil import yesMainThread
 from vortex.PayloadEnvelope import PayloadEnvelope
 from vortex.PayloadEnvelope import VortexMsgList
@@ -64,12 +64,11 @@ _ConnectionDateSuccess = namedtuple(
 
 
 class _VortexConnectionRateLimit:
-    _ROLLING_WINDOW_SECONDS = 10.0
-    _NEW_CONNECTIONS_IN_WINDOW = 5
-
     def __init__(self):
         self._connections: list[_ConnectionDateSuccess] = []
         self._peerConnectionLimitPerIp = None
+        self._newConnectionsPerWindow = 5
+        self._rollingNewConnectionWindowSeconds = 10.0
 
     def _hasHitPeerConnectionLimit(
         self, connectionCountForPeer: int, fromIp: str
@@ -103,7 +102,7 @@ class _VortexConnectionRateLimit:
         self._connections = list(
             filter(
                 lambda item: (now - item.dateTime).total_seconds()
-                < self._ROLLING_WINDOW_SECONDS,
+                < self._rollingNewConnectionWindowSeconds,
                 self._connections,
             )
         )
@@ -112,7 +111,7 @@ class _VortexConnectionRateLimit:
             list(filter(lambda item: item.success, self._connections))
         )
 
-        if connectedInWindow < self._NEW_CONNECTIONS_IN_WINDOW:
+        if connectedInWindow < self._newConnectionsPerWindow:
             self._connections.append(_ConnectionDateSuccess(now, True, fromIp))
             return True
 
@@ -133,17 +132,27 @@ class _VortexConnectionRateLimit:
 
         return False
 
+    def setNewConnectionsPerWindow(self, limit):
+        self._newConnectionsPerWindow = limit
+
     def setPeerConnectionLimitPerIp(self, limit):
         self._peerConnectionLimitPerIp = limit
 
+    def setRollingNewConnectionWindowSeconds(self, seconds):
+        self._rollingNewConnectionWindowSeconds = seconds
+
 
 VortexUuidList = List[str]
 
 
 class _VortexFactoryVortexInfo:
     def __init__(self):
-        self.__vortexServersByName: Dict[str, List[VortexServer]] = defaultdict(list)
-        self.__vortexClientsByName: Dict[str, List[VortexABC]] = defaultdict(list)
+        self.__vortexServersByName: Dict[str, List[VortexServer]] = defaultdict(
+            list
+        )
+        self.__vortexClientsByName: Dict[str, List[VortexABC]] = defaultdict(
+            list
+        )
 
         self.__vortexServers: tuple[VortexServer] = tuple()
         self.__vortexClients: tuple[VortexABC] = tuple()
@@ -241,12 +250,16 @@ class _VortexFactoryVortexInfo:
 
         self.__remoteVortexUuids = set(self.__remoteVortexNameByUuid)
 
-    def getRemoteVortexInfos(self, name=None, uuid=None) -> list[tuple[VortexABC, str]]:
+    def getRemoteVortexInfos(
+        self, name=None, uuid=None
+    ) -> list[tuple[VortexABC, str]]:
         assert name or uuid, "We expect a name or uuid"
 
         # If we're passed a UUID, then there will only be one result
         if uuid:
-            vortex, foundName = self.__remoteVortexNameByUuid.get(uuid, (None, None))
+            vortex, foundName = self.__remoteVortexNameByUuid.get(
+                uuid, (None, None)
+            )
             if not foundName:
                 return []
             return [(vortex, uuid)]
@@ -254,7 +267,9 @@ class _VortexFactoryVortexInfo:
         # Name is asserted
         return [
             (vortex, foundUuid)
-            for vortex, foundUuid in self.__remoteVortexUuidsByName.get(name, [])
+            for vortex, foundUuid in self.__remoteVortexUuidsByName.get(
+                name, []
+            )
         ]
 
     def getRemoteVortexIpByUuid(self, vortexUuid: str, vortexName=None) -> str:
@@ -267,7 +282,10 @@ class _VortexFactoryVortexInfo:
                     not conn.closed
                     and not conn.timedOut
                     and conn.remoteVortexUuid == vortexUuid
-                    and (conn.remoteVortexName == vortexName or vortexName is None)
+                    and (
+                        conn.remoteVortexName == vortexName
+                        or vortexName is None
+                    )
                 ):
                     targetConns.append(conn)
 
@@ -283,7 +301,9 @@ class _VortexFactoryVortexInfo:
             return targetConns[-1].ip
 
         if not targetConns:
-            raise NoVortexException(f"Can not find vortex with UUID {vortexUuid}")
+            raise NoVortexException(
+                f"Can not find vortex with UUID {vortexUuid}"
+            )
 
         return targetConns[0].ip
 
@@ -300,7 +320,10 @@ class _VortexFactoryVortexInfo:
                     not conn.closed
                     and not conn.timedOut
                     and conn.ip == ip
-                    and (conn.remoteVortexName == vortexName or vortexName is None)
+                    and (
+                        conn.remoteVortexName == vortexName
+                        or vortexName is None
+                    )
                 ):
                     targetConns.append(conn)
 
@@ -348,7 +371,9 @@ class _VortexFactoryVortexInfo:
     def getLocalVortexClients(self, localVortexName: str) -> List[VortexABC]:
         return [
             vortex
-            for vortex, _ in self.__localVortexUuidsByName.get(localVortexName, [])
+            for vortex, _ in self.__localVortexUuidsByName.get(
+                localVortexName, []
+            )
         ]
 
     def isRemoteVortexOnline(self, uuid):
@@ -401,6 +426,14 @@ class VortexFactory:
     def setPeerConnectionLimitPerIp(cls, limit: int):
         cls.__connectionRateLimit.setPeerConnectionLimitPerIp(limit)
 
+    @classmethod
+    def setNewConnectionsPerWindow(cls, limit):
+        cls.__connectionRateLimit.setNewConnectionsPerWindow(limit)
+
+    @classmethod
+    def setRollingNewConnectionWindowSeconds(cls, seconds):
+        cls.__connectionRateLimit.setRollingNewConnectionWindowSeconds(seconds)
+
     @classmethod
     def createServer(cls, name: str, rootResource) -> None:
         """Create Server
@@ -474,7 +507,9 @@ class VortexFactory:
 
         vortexServer = VortexServer(name, requiresBase64Encoding=False)
         cls.__vortexInfoState.addVortexServer(name, vortexServer)
-        vortexWebsocketServerFactory = VortexWebsocketServerFactory(vortexServer)
+        vortexWebsocketServerFactory = VortexWebsocketServerFactory(
+            vortexServer
+        )
         site = WebSocketFactory(vortexWebsocketServerFactory)
         if enableSsl:
             trustedCertificateAuthorities = None
@@ -507,12 +542,18 @@ class VortexFactory:
         cls.__listeningPorts.append(port)
 
     @classmethod
-    def createHttpWebsocketResource(cls, name: str) -> VortexWebSocketUpgradeResource:
+    def createHttpWebsocketResource(
+        cls, name: str
+    ) -> VortexWebSocketUpgradeResource:
         vortexServer = VortexServer(name, requiresBase64Encoding=False)
         cls.__vortexInfoState.addVortexServer(name, vortexServer)
 
-        vortexWebsocketServerFactory = VortexWebsocketServerFactory(vortexServer)
-        websocketFactory = VortexWrappedWebSocketFactory(vortexWebsocketServerFactory)
+        vortexWebsocketServerFactory = VortexWebsocketServerFactory(
+            vortexServer
+        )
+        websocketFactory = VortexWrappedWebSocketFactory(
+            vortexWebsocketServerFactory
+        )
 
         return VortexWebSocketUpgradeResource(websocketFactory)
 
@@ -532,8 +573,12 @@ class VortexFactory:
 
         vortexServer = VortexServer(name, requiresBase64Encoding=False)
         cls.__vortexInfoState.addVortexServer(name, vortexServer)
-        vortexWebsocketServerFactory = VortexWebsocketServerFactory(vortexServer)
-        websocketFactory = VortexWrappedWebSocketFactory(vortexWebsocketServerFactory)
+        vortexWebsocketServerFactory = VortexWebsocketServerFactory(
+            vortexServer
+        )
+        websocketFactory = VortexWrappedWebSocketFactory(
+            vortexWebsocketServerFactory
+        )
 
         websocketResource = VortexWebSocketUpgradeResource(websocketFactory)
         rootResource.putChild(b"vortexws", websocketResource)
@@ -622,8 +667,12 @@ class VortexFactory:
             sslMutualTLSCertificateAuthorityBundleFilePath,
             sslMutualTLSTrustedPeerCertificateBundleFilePath,
         )
-        vortexWebsocketClientFactory = VortexClientWebsocketFactory(name, url=url)
-        cls.__vortexInfoState.addVortexClient(name, vortexWebsocketClientFactory)
+        vortexWebsocketClientFactory = VortexClientWebsocketFactory(
+            name, url=url
+        )
+        cls.__vortexInfoState.addVortexClient(
+            name, vortexWebsocketClientFactory
+        )
 
         if vortexWebsocketClientFactory.isSecure and sslEnableMutualTLS:
             trustedCertificateAuthorities = parseTrustRootFromBundle(
@@ -654,7 +703,9 @@ class VortexFactory:
             # raise minimum version to tls 1.2
             sslContextFactory.method = SSL.TLSv1_2_METHOD
 
-        return vortexWebsocketClientFactory.connect(host, port, sslContextFactory)
+        return vortexWebsocketClientFactory.connect(
+            host, port, sslContextFactory
+        )
 
     @classmethod
     def createTcpClient(cls, name: str, host: str, port: int) -> Deferred:
@@ -678,7 +729,9 @@ class VortexFactory:
 
     @classmethod
     def addCustomServerVortex(cls, vortex: VortexABC):
-        cls.__vortexInfoState.addVortexServer(vortex.localVortexInfo.name, vortex)
+        cls.__vortexInfoState.addVortexServer(
+            vortex.localVortexInfo.name, vortex
+        )
 
     @classmethod
     def canConnect(cls, fromIp: str) -> bool:
@@ -778,13 +831,17 @@ class VortexFactory:
         if [v for v in vortexAndUuids if v[0].requiresBase64Encoding]:
             for index, vortexMsg in enumerate(base64VortexMsgs):
                 if vortexMsg.startswith(b"{"):
-                    base64VortexMsgs[index] = yield PayloadEnvelope.base64EncodeDefer(
-                        vortexMsg
-                    )
+                    base64VortexMsgs[
+                        index
+                    ] = yield PayloadEnvelope.base64EncodeDefer(vortexMsg)
 
         deferreds = []
         for vortex, uuid in vortexAndUuids:
-            msgToUse = base64VortexMsgs if vortex.requiresBase64Encoding else vortexMsgs
+            msgToUse = (
+                base64VortexMsgs
+                if vortex.requiresBase64Encoding
+                else vortexMsgs
+            )
             deferreds.append(vortex.sendVortexMsg(msgToUse, uuid))
 
         results = yield DeferredList(deferreds)
@@ -811,7 +868,9 @@ class VortexFactory:
         httpSession = "local"
         sendResponse = VortexFactory.sendVortexMsgLocally
 
-        vortexMsgs = [vortexMsgs] if isinstance(vortexMsgs, bytes) else vortexMsgs
+        vortexMsgs = (
+            [vortexMsgs] if isinstance(vortexMsgs, bytes) else vortexMsgs
+        )
 
         def send(payloadEnvelope: PayloadEnvelope):
             try:

{vortexpy-4.0.3/vortex/test → vortexpy-4.0.6/vortex}/VortexTcpMemoryLeakRawTest.py

@@ -12,7 +12,7 @@ from twisted.internet import reactor
 from twisted.internet.defer import inlineCallbacks, Deferred
 from twisted.trial import unittest
 
-from vortex.test.VortexTcpMemoryLeakPayloadTest import (
+from vortex.VortexTcpMemoryLeakPayloadTest import (
     MemoryCheckerTestMixin,
     VortexTcpConnectTestMixin,
 )
@@ -49,8 +49,8 @@ class VortexTcpMemoryLeakRawTest(
 
         dataSent = 0
         for _ in range(1024):
-            dataSent += 1024 ** 2
-            self._vortexServer.sendVortexMsg(b"x" * 1024 ** 2)
+            dataSent += 1024**2
+            self._vortexServer.sendVortexMsg(b"x" * 1024**2)
 
         # while dataSent < self._patchedProcessData_dataReceivedLen:
         for _ in range(2):

{vortexpy-4.0.3 → vortexpy-4.0.6}/vortex/__init__.py

@@ -7,4 +7,4 @@
  * Support : support@synerty.com
 """
 
-__version__ = '4.0.3'
+__version__ = '4.0.6'