vortexpy 4.0.23__py3-none-any.whl

vortex/TupleAction.py

@@ -0,0 +1,72 @@
+"""
+ * Created by Synerty Pty Ltd
+ *
+ * This software is open source, the MIT license applies.
+ *
+ * Website : http://www.synerty.com
+ * Support : support@synerty.com
+"""
+import uuid
+from datetime import datetime
+from typing import Dict
+from typing import List
+
+import pytz
+
+from vortex.Tuple import Tuple
+from vortex.Tuple import TupleField
+from vortex.Tuple import addTupleType
+from vortex.TupleSelector import TupleSelector
+
+
+class TupleActionABC(Tuple):
+    uuid: str = TupleField(
+        comment="Uniquely generated id for this action", typingType=str
+    )
+    dateTime: datetime = TupleField(
+        comment="The datetime this action was created", typingType=datetime
+    )
+
+    def __init__(self, **kwargs):
+        if not self.__tupleType__:
+            raise NotImplementedError(
+                "TupleActionABC can not be instantiated,"
+                " please inherit it and implement a tuple"
+            )
+
+        Tuple.__init__(self, **kwargs)
+
+        if not "uuid" in kwargs:
+            self.uuid = str(uuid.uuid1())  # Based on the host, and the time
+
+        if not "dateTime" in kwargs:
+            self.dateTime = datetime.now(pytz.utc)
+
+
+@addTupleType
+class TupleGenericAction(TupleActionABC):
+    """Tuple Generic Action
+
+    This is a generic action, to be used when the implementor doesn't want to implement
+    concrete classes for each action type.
+
+    """
+
+    __tupleType__ = "vortex.TupleGenericAction"
+
+    key = TupleField(comment="An optional key for this action", typingType=str)
+
+    data = TupleField(comment="Optional data for the update", typingType=str)
+
+
+@addTupleType
+class TupleUpdateAction(TupleActionABC):
+    __tupleType__ = "vortex.TupleUpdateAction"
+
+    tupleSelector = TupleField(
+        comment="The tuple selector for this action", typingType=TupleSelector
+    )
+    tupleChanges = TupleField(
+        comment="An array of {old:v,new:v} dicts for the changes",
+        typingType=List[Dict],
+    )

vortex/TupleActionVortex.py

@@ -0,0 +1,5 @@
+class TupleActionVortex:
+    def __init__(self, vortexName, vortexUuid, httpSession):
+        self.name = vortexName
+        self.uuid = vortexUuid
+        self.httpSession = httpSession

vortex/TupleDataForTest.py

@@ -0,0 +1,25 @@
+"""
+ * Created by Synerty Pty Ltd
+ *
+ * This software is open source, the MIT license applies.
+ *
+ * Website : http://www.synerty.com
+ * Support : support@synerty.com
+"""
+from vortex.TestTuple import TestTuple
+
+
+def makeTestTupleData(count=5):
+    tuples = []
+    for num in range(count):
+        uniStr = "#%s double hyphen :-( — “fancy quotes”" % num
+        tuples.append(
+            TestTuple(
+                aInt=num,
+                aBoolTrue=bool(num % 2),
+                aString="This is tuple #%s" % num,
+                aStrWithUnicode=uniStr,
+            )
+        )
+
+    return tuples

vortex/TuplePerfTest.py

@@ -0,0 +1,71 @@
+import gc
+import os
+from datetime import datetime
+
+import psutil
+import pytz
+
+process = psutil.Process(os.getpid())
+
+ITER_COUNT = 1000 * 1000 * 5
+
+RESULT = None
+
+
+def makeL(i):
+    # Use this line to negate the effect of the strings on the test
+    # return "Python is smart and will only create one string with this line"
+
+    # Use this if you want to see the difference with 5 million unique strings
+    return "This is a sample string %s" % i
+
+
+def timeit(method):
+    def timed(*args, **kw):
+        global RESULT
+        RESULT = None
+        gc.collect()
+
+        s = datetime.now(pytz.utc)
+        startMem = process.memory_info().rss
+        RESULT = method(*args, **kw)
+        e = datetime.now(pytz.utc)
+        endMem = process.memory_info().rss
+
+        sizeMb = (endMem - startMem) / 1024 / 1024
+        sizeMbStr = "{0:,}".format(round(sizeMb, 2))
+
+        print(
+            "Time Taken = %s, \t%s, \tSize = %s"
+            % (e - s, method.__name__, sizeMbStr)
+        )
+
+    return timed
+
+
+from vortex.Tuple import Tuple, addTupleType, TupleHash
+from vortex.Payload import Payload
+
+
+@addTupleType
+class X(Tuple):
+    __tupleType__ = "X"
+    __slots__ = ["i", "l"]
+
+    def __init__(self, i=None, l=None):
+        self.i, self.l = i, l
+
+
+@timeit
+def provile_dict_of_nt():
+    return [X(i=i, l=makeL(i)) for i in range(ITER_COUNT)]
+
+
+if __name__ == "__main__":
+    provile_dict_of_nt()
+
+    tupleIn = X("val1", "val2")
+    encodedPayload = Payload(tuples=[tupleIn]).toEncodedPayload()
+    payload = Payload().fromEncodedPayload(encodedPayload)
+
+    assert TupleHash(tupleIn) == TupleHash(payload.tuples[0])

vortex/TuplePolymorphicTupleTypeFieldArgTest.py

@@ -0,0 +1,74 @@
+import logging
+import unittest
+
+from vortex.Tuple import (
+    Tuple,
+    addTupleType,
+    TupleField,
+    PolymorphicTupleTypeFieldArg,
+    TupleHash,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@addTupleType
+class Parent(Tuple):
+    __tupleType__ = "com.synerty.Tuples.Parent"
+    __tupleArgs__ = (PolymorphicTupleTypeFieldArg("concreteType"),)
+
+    aStr: str = TupleField()
+    concreteType: str = TupleField()
+
+
+@addTupleType
+class Child(Parent):
+    __tupleType__ = "com.synerty.Tuples.Child"
+
+    aInt: int = TupleField()
+
+
+@addTupleType
+class Another(Tuple):
+    __tupleType__ = "com.synerty.Tuples.Another"
+
+    aInt: int = TupleField()
+    concreteType: str = TupleField()
+
+
+class PolymorphicTupleTypeFieldArgTest(unittest.TestCase):
+    def testParentTupleToFromJSON(self):
+        parent1 = Parent(aStr="Test", concreteType=Parent.tupleType())
+        parent2 = Parent(aStr="Test", concreteType=Parent.tupleType())
+        parent3 = Parent(aStr="Test 1", concreteType=Parent.tupleType())
+
+        self.assertEqual(TupleHash(parent1), TupleHash(parent2))
+        self.assertNotEqual(TupleHash(parent1), TupleHash(parent3))
+
+    def testChildFieldsInToJsonDict(self):
+        data = dict(aStr="Test", aInt=1, concreteType=Child.tupleType())
+        child = Child(**data)
+
+        self.assertEqual(data, child.tupleToRestfulJsonDict())
+
+    def testChildTupleToFromJSON(self):
+        # Construct Child through Child
+        child1 = Child(aStr="Test", aInt=1, concreteType=Child.tupleType())
+
+        # Construct Child through Parent
+        child2 = Tuple.restfulJsonDictToTupleWithValidation(
+            child1.tupleToRestfulJsonDict(), Parent
+        )
+
+        self.assertEqual(TupleHash(child1), TupleHash(child2))
+
+        # Parent should not match Child
+        parent1 = Parent(aStr="Test", concreteType=Parent.tupleType())
+        self.assertNotEqual(TupleHash(child1), TupleHash(parent1))
+
+        # Parent should only be able to init its children
+        another1 = Another(aInt=1, concreteType=Another.tupleType())
+        with self.assertRaises(TypeError):
+            Tuple.restfulJsonDictToTupleWithValidation(
+                another1.tupleToRestfulJsonDict(), Parent
+            )

vortex/TupleRestfulTest.py

@@ -0,0 +1,140 @@
+"""
+ * Created by Synerty Pty Ltd
+ *
+ * This software is open source, the MIT license applies.
+ *
+ * Website : http://www.synerty.com
+ * Support : support@synerty.com
+"""
+
+import json
+from typing import Dict, Annotated
+from typing import List
+from typing import Union
+
+from ddt import data, ddt
+from twisted.trial import unittest
+
+from vortex.Tuple import Tuple
+from vortex.Tuple import TupleField
+from vortex.Tuple import TupleHash, IntTupleFieldValidator
+from vortex.Tuple import addTupleType
+
+
+@addTupleType
+class RestfulTestTuple(Tuple):
+    """
+    classdocs
+    """
+
+    __tupleType__ = "synerty.vortex.RestfulTestTuple"
+    aInt: int = TupleField()
+    aIntWithValidator: Annotated[
+        int, IntTupleFieldValidator(1, 100)
+    ] = TupleField()
+    aFloat: float = TupleField()
+    aString: str = TupleField()
+    aBoolTrue: bool = TupleField()
+    aBoolFalse: bool = TupleField()
+    aList: List[Union[str, int, bool, float]] = TupleField()
+    aDict: Dict[str, Union[str, float]] = TupleField()
+    aSubTuple: "RestfulSubTestTuple" = TupleField()
+    aListOfSubTuples: List["RestfulSubTestTuple"] = TupleField()
+    aDictOfSubTuples: Dict[str, "RestfulSubTestTuple"] = TupleField()
+
+
+@addTupleType
+class RestfulSubTestTuple(Tuple):
+    """Test Sub Tuple
+    This tuple will test if we can have tuples in tuples and still serialise and
+    deserialise them.
+    """
+
+    __tupleType__ = "rapui.synerty.RestfulSubTestTuple"
+    subInt: int = TupleField()
+
+
+def _makeRestfultTestTuple():
+    tuple_ = RestfulTestTuple()
+    tuple_.aBoolTrue = True
+    tuple_.aBoolFalse = False
+    tuple_.aFloat = 2.56
+    tuple_.aInt = 1231231
+    tuple_.aIntWithValidator = 50
+    tuple_.aString = "test string from 345345345@$#%#$%#$%#$%#"
+    tuple_.aList = ["y", 3, True, 3.3]
+    tuple_.aDict = {
+        "a": "test str",
+        "1": 1.234,
+    }  # Key strings are loaded as unicode
+    tuple_.aDictOfSubTuples = {}
+
+    subTuple = RestfulSubTestTuple()
+    subTuple.subInt = 2048
+    tuple_.aSubTuple = subTuple
+
+    tuple_.aListOfSubTuples = []
+    for x in range(2):
+        subTuple = RestfulSubTestTuple()
+        subTuple.subInt = x
+        tuple_.aListOfSubTuples.append(subTuple)
+
+        subTuple = RestfulSubTestTuple()
+        subTuple.subInt = x + 10
+        tuple_.aDictOfSubTuples[str(x)] = subTuple
+
+    return tuple_
+
+
+@ddt
+class TupleRestfulTest(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def _testSerialisation(self, origTuple):
+        # To Restful JSON Object
+        jsonDict = origTuple.tupleToRestfulJsonDict()
+        # Pass it through the JSON object to JSON string conversion
+        jsonDict = json.loads(json.dumps(jsonDict))
+        # Reconstruct a new Tuple
+        deserialisedTuple = (
+            RestfulTestTuple().restfulJsonDictToTupleWithValidation(
+                jsonDict, RestfulTestTuple
+            )
+        )
+        return deserialisedTuple
+
+    @data(-1, 110)
+    def testIntValidatorInvalid(self, int_):
+        # Create tuple
+        origTuple = _makeRestfultTestTuple()
+        origTuple.aIntWithValidator = int_
+        self.assertRaises(ValueError, self._testSerialisation, origTuple)
+
+    @data(1, 99)
+    def testIntValidatorValid(self, int_):
+        # Create tuple
+        origTuple = _makeRestfultTestTuple()
+        origTuple.aIntWithValidator = int_
+        self.assertEqual(
+            self._testSerialisation(origTuple).aIntWithValidator, int_
+        )
+
+    def testValidatorPass(self):
+        # Create tuple
+        origTuple = _makeRestfultTestTuple()
+
+        deserialisedTuple = self._testSerialisation(origTuple)
+
+        self.assertEqual(TupleHash(origTuple), TupleHash(origTuple))
+        self.assertEqual(
+            TupleHash(deserialisedTuple), TupleHash(deserialisedTuple)
+        )
+        self.assertEqual(
+            TupleHash(origTuple),
+            TupleHash(deserialisedTuple),
+            "Tuple serialise -> deserialise error",
+        )

vortex/TupleSelector.py

@@ -0,0 +1,105 @@
+"""
+ * Created by Synerty Pty Ltd
+ *
+ * This software is open source, the MIT license applies.
+ *
+ * Website : http://www.synerty.com
+ * Support : support@synerty.com
+"""
+import json
+from typing import Dict, Optional, Union, Type
+
+from vortex.Tuple import Tuple, addTupleType
+
+
+class InvalidTupleSelectorNameException(Exception):
+    pass
+
+
+@addTupleType
+class TupleSelector(Tuple):
+    __tupleType__ = "vortex.TupleSelector"
+    __slots__ = ["name", "selector"]
+
+    # name: str = TupleField(comment="The tuple name this selector is for")
+    # selector: Dict[str, Any] = TupleField(comment="The values to select")
+
+    def __init__(
+        self,
+        name: Optional[Union[str, Type[Tuple], Tuple]] = None,
+        selector: Optional[Dict] = None,
+    ) -> None:
+        Tuple.__init__(self)
+        self.name = self.nameFromTuple(name)
+        self.selector = selector if selector else {}
+
+    def __eq__(self, y):
+        return self.toJsonStr() == y.toJsonStr()
+
+    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 isinstance(nameOrTuple, Tuple):
+            name = nameOrTuple.tupleType()
+
+        elif issubclass(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
+
+        This method dumps the c{TupleSelector} data to a json string.
+
+        It sorts the dict keys and
+        """
+        fieldJsonDict = self.toJsonField(self.selector)
+        return json.dumps(
+            {"name": self.name, "selector": fieldJsonDict}, sort_keys=True
+        )
+
+    @classmethod
+    def fromJsonStr(cls, jsonStr: str) -> "TupleSelector":
+        """From Json Str
+
+        This method creates a new c{TupleSelector} from the ordered json string dumped
+        from .toJsonStr
+
+        """
+        data = json.loads(jsonStr)
+        newTs = TupleSelector(name=data["name"], selector={})
+        newTs.selector = newTs.fromJsonField(data["selector"])
+        return newTs
+
+    def __repr__(self):
+        return self.toJsonStr()

vortex/TupleTest.py

@@ -0,0 +1,127 @@
+"""
+ * Created by Synerty Pty Ltd
+ *
+ * This software is open source, the MIT license applies.
+ *
+ * Website : http://www.synerty.com
+ * Support : support@synerty.com
+"""
+
+import datetime
+import json
+
+from twisted.trial import unittest
+
+from vortex.TestTuple import TestSubTuple, TestTuple
+from vortex.Tuple import TupleHash
+
+
+def makeTupleA():
+    tuple_ = TestTuple()
+    tuple_.aBoolTrue = True
+    tuple_.aBoolFalse = False
+    tuple_.aDate = datetime.datetime(2010, 4, 7, 2, 33, 19, 666)
+    tuple_.aFloat = 2.56
+    tuple_.aInt = 1231231
+    tuple_.aString = "test string from 345345345@$#%#$%#$%#$%#"
+    tuple_.aSet = ["x", 2, False]  # Sets are restored as Lists
+    tuple_.aList = ["y", 3, True, 3.3]
+    tuple_.aDict = {
+        "a": "test str",  # Key strings are loaded as unicode
+        1: 1.234,
+    }
+
+    subTuple = TestSubTuple()
+    subTuple.subInt = 2048
+    tuple_.aSubTuple = subTuple
+    #
+    tuple_.aListOfSubTuples = []
+    for x in range(2):
+        subTuple = TestSubTuple()
+        subTuple.subInt = x
+        tuple_.aListOfSubTuples.append(subTuple)
+
+    return tuple_
+
+
+class TuplePyTest(unittest.TestCase):
+    PERFORMANCE_ITERATIONS = 10000
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def testTupleToFromJson(self):
+        # Create tuple
+        origTuple = makeTupleA()
+
+        # To Json
+        jsonDictStr = json.dumps(origTuple.toJsonDict())
+        deserialisedTuple = TestTuple().fromJsonDict(json.loads(jsonDictStr))
+        # print xmlStr
+
+        self.assertEqual(TupleHash(origTuple), TupleHash(origTuple))
+        self.assertEqual(
+            TupleHash(deserialisedTuple), TupleHash(deserialisedTuple)
+        )
+
+        # print TupleHash(origTuple)._key()
+        # print TupleHash(deserialisedTuple)._key()
+
+        self.assertEqual(
+            TupleHash(origTuple),
+            TupleHash(deserialisedTuple),
+            "Tuple serialise -> deserialise error",
+        )
+
+    def testTupleToFromJsonPerformanceMulti(self):
+        for _ in range(self.PERFORMANCE_ITERATIONS):
+            origTuple = makeTupleA()
+            jsonDictStr = json.dumps(origTuple.toJsonDict())
+            TestTuple().fromJsonDict(json.loads(jsonDictStr))
+
+    def testTupleToFromJsonPerformanceSingle(self):
+        origTuple = makeTupleA()
+        origTuple.aListOfSubTuples = [
+            makeTupleA() for _ in range(self.PERFORMANCE_ITERATIONS)
+        ]
+        jsonDictStr = json.dumps(origTuple.toJsonDict())
+        TestTuple().fromJsonDict(json.loads(jsonDictStr))
+
+    def testTupleHash(self):
+        hashA1 = TupleHash(makeTupleA())
+        hashA2 = TupleHash(makeTupleA())
+        print("hashA1 = %s" % hashA1.__hash__())
+        print("hashA2 = %s" % hashA2.__hash__())
+
+        hashB1 = TupleHash(makeTupleA())
+        hashB1.tupl.aString = "Not the same as the others"
+        print("hashB1 = %s" % hashB1.__hash__())
+
+        hashA1.__hash__()
+        self.assertTrue(
+            hashA1.__hash__() == hashA1.__hash__(),
+            "TupleHash A1.__hash__() == A1.__hash__()",
+        )
+
+        self.assertTrue(hashA1 == hashA2, "TupleHash __eq__ fail, A1 == A2")
+        self.assertFalse(hashA1 != hashA2, "TupleHash __ne__ fail, A1 != A2")
+        self.assertFalse(hashA1 == hashB1, "TupleHash __eq__ fail, A1 == B1")
+        self.assertTrue(hashA1 != hashB1, "TupleHash __ne__ fail, A1 != B1")
+
+        self.assertTrue(
+            hashA1 in {hashA2: None}, "TupleHash in fail, A1 in {A2:None}"
+        )
+        self.assertFalse(
+            hashA1 not in {hashA2: None},
+            "TupleHash in fail, A1 not in {A2:None}",
+        )
+        self.assertTrue(
+            hashA1 not in {hashB1: None},
+            "TupleHash in fail, A1 not in {B1:None}",
+        )
+        self.assertFalse(
+            hashA1 in {hashB1: None}, "TupleHash in fail, A1 in {B1:None}"
+        )

vortex/VortexABC.py

@@ -0,0 +1,55 @@
+from abc import ABCMeta, abstractmethod
+from typing import Optional, Union, Callable, List
+
+from twisted.internet.defer import Deferred
+
+from vortex.PayloadEnvelope import VortexMsgList
+
+SendVortexMsgResponseCallable = Callable[
+    [Union[VortexMsgList, bytes], int], Deferred
+]
+
+
+class VortexInfo:
+    """Vortex Info
+
+    This class stores details about the end of a vortex.
+    """
+
+    def __init__(self, name, uuid):
+        self.name, self.uuid = name, uuid
+
+    def __repr__(self):
+        return "VortexInfo, Name=%s, UUID=%s" % (self.name, self.uuid)
+
+
+class VortexABC(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def localVortexInfo(self) -> VortexInfo:
+        pass
+
+    @property
+    @abstractmethod
+    def remoteVortexInfo(self) -> List[VortexInfo]:
+        pass
+
+    @property
+    @abstractmethod
+    def requiresBase64Encoding(self) -> bool:
+        pass
+
+    @abstractmethod
+    def sendVortexMsg(
+        self,
+        vortexMsgs: Union[VortexMsgList, bytes],
+        vortexUuid: Optional[str] = None,
+    ):
+        """Send Vortex Msg
+
+        Sends the vortex message to any conencted clients with vortexUuid.
+        Or broadcast it to all connected vortex clients if it's None
+
+        :param vortexMsgs: The vortex message(s) to send
+        :param vortexUuid: The vortexUuid of the client to send to.
+        """