vortexpy 6.0.0__tar.gz → 6.0.2__tar.gz

{vortexpy-6.0.0/vortexpy.egg-info → vortexpy-6.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 6.0.0
+Version: 6.0.2
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT
@@ -34,6 +34,8 @@ Flying Ion's observable, routable, data serialisation and transport code.
 See [README_PERMISSIONS.md](README_PERMISSIONS.md) for the two-level permission
 system (endpoint guards + access control context) introduced in v6.0.
 
+**Tuple and Payload tutorials:** [docs/README.md](docs/README.md) (simple → full features, encode/decode, threaded decode).
+
 Why PY at the end? To be consistent with VortexJS, which is the Browser side package.
 See https://gitlab.com/flyingion/vortexjs
 

{vortexpy-6.0.0 → vortexpy-6.0.2}/README.md

@@ -5,6 +5,8 @@ Flying Ion's observable, routable, data serialisation and transport code.
 See [README_PERMISSIONS.md](README_PERMISSIONS.md) for the two-level permission
 system (endpoint guards + access control context) introduced in v6.0.
 
+**Tuple and Payload tutorials:** [docs/README.md](docs/README.md) (simple → full features, encode/decode, threaded decode).
+
 Why PY at the end? To be consistent with VortexJS, which is the Browser side package.
 See https://gitlab.com/flyingion/vortexjs
 

vortexpy-6.0.2/example/TwistedDeferredTimeout.py

@@ -0,0 +1,50 @@
+# 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
+
+# from twisted.internet import task, defer
+#
+# def logTimeout(result, timeout):
+#     print("Got {0!r} but actually timed out after {1} seconds".format(
+#         result, timeout))
+#     return result + " (timed out)"
+#
+# def main(reactor):
+#     # generate a deferred with a custom canceller function, and never
+#     # never callback or errback it to guarantee it gets timed out
+#     d = defer.Deferred()#lambda c: c.callback("Everything's ok!"))
+#     d.addTimeout(2, reactor)#, onTimeoutCancel=logTimeout)
+#     d.addBoth(print)
+#     return d
+#
+# task.react(main)
+#
+
+
+import random
+
+from twisted.internet import task
+
+
+def f():
+    return "Hopefully this will be called in 3 seconds or less"
+
+
+def main(reactor):
+    delay = random.uniform(1, 5)
+
+    def called(result):
+        print("{0} seconds later:".format(delay), result)
+
+    d = task.deferLater(reactor, delay, f)
+    d.addTimeout(3, reactor).addBoth(called)
+
+    return d
+
+
+# f() will be timed out if the random delay is greater than 3 seconds
+task.react(main)

vortexpy-6.0.2/example/__init__.py

@@ -0,0 +1 @@
+"""Vortexpy runnable examples and local test servers."""

vortexpy-6.0.2/example/run_http_upgraded_websocket_ping_client.py

@@ -0,0 +1,68 @@
+# 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 logging
+from datetime import datetime
+
+import pytz
+from twisted.internet import task
+from twisted.internet.defer import inlineCallbacks
+
+from example.setup_example_logging import setupExampleLogging
+from vortex.PayloadEnvelope import PayloadEnvelope
+from vortex.PayloadResponse import PayloadResponse
+from vortex.VortexClientWebsocketFactory import VortexClientWebsocketFactory
+
+logger = logging.getLogger(__name__)
+
+
+setupExampleLogging()
+
+if __name__ == "__main__":
+    import sys
+
+    from twisted.python import log
+    from twisted.internet import reactor, ssl
+
+    log.startLogging(sys.stdout)
+
+    @inlineCallbacks
+    def sendMessage():
+        factory = VortexClientWebsocketFactory(
+            "test_websocket", url="ws://127.0.0.1:9000/vortexws"
+        )
+        yield factory.connect("127.0.0.1", 9000, ssl.ClientContextFactory())
+
+        filt = {
+            "key": "ws_test",
+        }
+
+        while True:
+            payloadEnvelope = PayloadEnvelope(filt)
+            payloadEnvelope.encodedPayload = b"*" * 163880
+            responseDeferred = PayloadResponse(payloadEnvelope)
+            logger.info(payloadEnvelope.date)
+
+            # factory.sendVortexMsg(payload.toVortexMsg())
+
+            factory.sendVortexMsg(
+                payloadEnvelope.toVortexMsg(base64Encode=False)
+            )
+            logger.info(payloadEnvelope.date)
+
+            yield responseDeferred
+            logger.info(
+                "CALL COMPLETE, Time Taken: %s",
+                datetime.now(pytz.utc) - payloadEnvelope.date,
+            )
+
+            yield task.deferLater(reactor, 5, lambda: None)
+
+    reactor.callLater(0.5, sendMessage)
+
+    reactor.run()

vortexpy-6.0.2/example/run_http_upgraded_websocket_ping_server.py

@@ -0,0 +1,71 @@
+# 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 logging
+import os
+
+from twisted.web import server
+from txwebsocket.txws import WebSocketUpgradeHTTPChannel
+
+from example.setup_example_logging import setupExampleLogging
+from txhttputil.site.FileUnderlayResource import FileUnderlayResource
+from vortex.PayloadEndpoint import PayloadEndpoint
+from vortex.PayloadEnvelope import PayloadEnvelope
+from vortex.VortexABC import SendVortexMsgResponseCallable
+from vortex.VortexFactory import VortexFactory
+
+logger = logging.getLogger(__name__)
+
+setupExampleLogging()
+
+if __name__ == "__main__":
+    import sys
+
+    from twisted.python import log
+    from twisted.internet import reactor
+
+    log.startLogging(sys.stdout)
+
+    resource = FileUnderlayResource()
+    resource.enableSinglePageApplication()
+    resource.addFileSystemRoot(
+        os.path.dirname(os.path.realpath(__file__)) + "/test_serve"
+    )
+
+    site = server.Site(resource)
+    site.protocol = WebSocketUpgradeHTTPChannel
+
+    class Test:
+        def logDate(
+            self,
+            payloadEnvelope: PayloadEnvelope,
+            sendResponse: SendVortexMsgResponseCallable,
+            *args,
+            **kwargs,
+        ):
+            logger.info(payloadEnvelope.filt)
+            logger.info(payloadEnvelope.date)
+
+            sendResponse(payloadEnvelope.toVortexMsg())
+
+    test = Test()
+    endpoint = PayloadEndpoint(
+        filt={
+            "key": "ws_test",
+        },
+        callable_=test.logDate,
+    )
+
+    # VortexFactory.createWebsocketServer("test_websocket", 9000)
+
+    VortexFactory.createHttpWebsocketServer("vortexws", resource)
+    reactor.listenTCP(9000, site)
+
+    reactor.run()
+
+    endpoint.shutdown()

vortexpy-6.0.2/example/run_http_upgraded_websocket_rpc_test_client.py

@@ -0,0 +1,67 @@
+# 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 logging
+from datetime import datetime
+
+import pytz
+from twisted.internet import reactor
+from twisted.internet import task
+from twisted.internet.defer import inlineCallbacks
+
+from example.setup_example_logging import setupExampleLogging
+from vortex.DeferUtil import vortexLogFailure
+from vortex.VortexFactory import VortexFactory
+from vortex.rpc.RPCTest import myRemoteAddMethod
+from vortex.rpc.RPCTest import myRemoteExceptionMethod
+
+logger = logging.getLogger(__name__)
+
+setupExampleLogging()
+
+
+@inlineCallbacks
+def connect():
+    # BEGIN WEBSOCKET HTTP UPGRADED CLIENT CONNECT
+
+    yield VortexFactory.createWebsocketClient(
+        name="sendVortexName",
+        host="127.0.0.1",
+        port=10101,
+        url="ws://127.0.0.1:10101/vortexws",
+    )
+    # END WEBSOCKET HTTP UPGRADED CLIENT CONNECT
+
+
+def callRpcException():
+    d = myRemoteExceptionMethod(7, kwarg1=4)
+    d.addCallback(lambda v: logger.debug("SUCCESS, result = %s", v))
+    d.addErrback(vortexLogFailure, logger)
+    return d
+
+
+@inlineCallbacks
+def callRpc():
+    while True:
+        startDate = datetime.now(pytz.utc)
+        v = yield myRemoteAddMethod(7, kwarg1=4)
+        logger.debug(
+            "CALL COMPLETE, result = %s, Time Taken: %s",
+            v,
+            datetime.now(pytz.utc) - startDate,
+        )
+
+        yield task.deferLater(reactor, 5, lambda: None)
+
+
+if __name__ == "__main__":
+    reactor.callLater(0, logger.info, "RPCTest client running")
+    reactor.callLater(0, connect)
+    reactor.callLater(25, callRpcException)
+    reactor.callLater(28, callRpc)
+    reactor.run()

vortexpy-6.0.2/example/run_http_upgraded_websocket_rpc_test_server.py

@@ -0,0 +1,45 @@
+# 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 logging
+import os
+
+from twisted.internet import reactor
+from twisted.web import server
+from txhttputil.site.FileUnderlayResource import FileUnderlayResource
+from txwebsocket.txws import WebSocketUpgradeHTTPChannel
+
+from example.setup_example_logging import setupExampleLogging
+from vortex.VortexFactory import VortexFactory
+from vortex.rpc.RPCTest import myRemoteAddMethod
+from vortex.rpc.RPCTest import myRemoteExceptionMethod
+
+logger = logging.getLogger(__name__)
+
+setupExampleLogging()
+
+if __name__ == "__main__":
+    # BEGIN WEBSOCKET HTTP UPGRADED CLIENT CONNECT
+    resource = FileUnderlayResource()
+    resource.enableSinglePageApplication()
+    resource.addFileSystemRoot(
+        os.path.dirname(os.path.realpath(__file__)) + "/test_serve"
+    )
+
+    site = server.Site(resource)
+    site.protocol = WebSocketUpgradeHTTPChannel
+
+    VortexFactory.createHttpWebsocketServer("listenVortexName", resource)
+    reactor.listenTCP(10101, site)
+    # END WEBSOCKET HTTP UPGRADED CLIENT CONNECT
+
+    reactor.callLater(0, logger.info, "RPCTest server running")
+
+    reactor.callLater(0, myRemoteExceptionMethod.start)
+    reactor.callLater(0, myRemoteAddMethod.start)
+    reactor.run()

vortexpy-6.0.2/example/run_websocket_rpc_test_client.py

@@ -0,0 +1,64 @@
+# 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 logging
+from datetime import datetime
+
+import pytz
+from twisted.internet import reactor
+from twisted.internet import task
+from twisted.internet.defer import inlineCallbacks
+
+from example.setup_example_logging import setupExampleLogging
+from vortex.DeferUtil import vortexLogFailure
+from vortex.VortexFactory import VortexFactory
+from vortex.rpc.RPCTest import myRemoteAddMethod
+from vortex.rpc.RPCTest import myRemoteExceptionMethod
+
+logger = logging.getLogger(__name__)
+
+setupExampleLogging()
+
+
+@inlineCallbacks
+def connect():
+    # BEGIN WEBSOCKET CLIENT CONNECT
+    yield VortexFactory.createWebsocketClient(
+        "sendVortexName", "127.0.0.1", 10102, "ws://127.0.0.1:10102/vortexws"
+    )
+    # END WEBSOCKET CLIENT CONNECT
+
+    reactor.callLater(2, callRpcException)
+    reactor.callLater(5, callRpc)
+
+
+def callRpcException():
+    d = myRemoteExceptionMethod(7, kwarg1=4)
+    d.addCallback(lambda v: logger.debug("SUCCESSS, result = %s", v))
+    d.addErrback(vortexLogFailure, logger)
+    return d
+
+
+@inlineCallbacks
+def callRpc():
+    while True:
+        startDate = datetime.now(pytz.utc)
+        v = yield myRemoteAddMethod(7, kwarg1=4)
+        logger.debug(
+            "CALL COMPLETE, result = %s, Time Taken: %s",
+            v,
+            datetime.now(pytz.utc) - startDate,
+        )
+
+        yield task.deferLater(reactor, 5, lambda: None)
+
+
+if __name__ == "__main__":
+    reactor.callLater(0, logger.info, "RPCTest client running")
+    reactor.callLater(0, connect)
+    reactor.run()

vortexpy-6.0.2/example/run_websocket_rpc_test_server.py

@@ -0,0 +1,29 @@
+# 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 logging
+
+from twisted.internet import reactor
+
+from vortex.VortexFactory import VortexFactory
+from vortex.rpc.RPCTest import myRemoteAddMethod
+from vortex.rpc.RPCTest import myRemoteExceptionMethod
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+
+if __name__ == "__main__":
+    # BEGIN WEBSOCKET CLIENT CONNECT
+    VortexFactory.createWebsocketServer("listenVortexName", 10102)
+    # END WEBSOCKET CLIENT CONNECT
+
+    reactor.callLater(0, logger.info, "RPCTest server running")
+
+    reactor.callLater(0, myRemoteExceptionMethod.start)
+    reactor.callLater(0, myRemoteAddMethod.start)
+    reactor.run()

vortexpy-6.0.2/example/setup_example_logging.py

@@ -0,0 +1,44 @@
+# 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 logging
+import sys
+from datetime import datetime
+
+from twisted.internet import defer
+
+
+def setupExampleLogging():
+    defer.setDebugging(True)
+    logging.root.setLevel(logging.DEBUG)
+
+    console = logging.StreamHandler()
+    logging.root.addHandler(console)
+
+    class MyFormatter(logging.Formatter):
+        converter = datetime.fromtimestamp
+
+        def formatTime(self, record, datefmt=None):
+            ct = self.converter(record.created)
+            if datefmt:
+                s = ct.strftime(datefmt)
+            else:
+                t = ct.strftime("%Y-%m-%d %H:%M:%S")
+                s = "%s,%03d" % (t, record.msecs)
+            return s
+
+    formatter = MyFormatter(
+        fmt="%(asctime)s %(message)s", datefmt="%Y-%m-%d,%H:%M:%S.%f"
+    )
+    console.setFormatter(formatter)
+
+    # Start the twisted logging
+
+    from twisted.python import log
+
+    log.startLogging(sys.stdout)

vortexpy-6.0.2/example/store_and_load_json.py

@@ -0,0 +1,68 @@
+# 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
+import os.path
+
+from vortex.Tuple import Tuple
+from vortex.Tuple import TupleField
+from vortex.Tuple import addTupleType
+
+JSON_DIR = os.path.expanduser("~/my-app-storage.json")
+
+
+@addTupleType
+class MyItem(Tuple):
+    __tupleType__ = "MyItem"
+    myBool: bool = TupleField()
+    myStr: str = TupleField()
+
+
+@addTupleType
+class MyData(Tuple):
+    __tupleType__ = "MyData"
+    myItems: list[MyItem] = TupleField([])
+    myName: str = TupleField()
+
+
+def store(tuple_: Tuple):
+    jsonObj = tuple_.tupleToRestfulJsonDict()
+    jsonStr = json.dumps(
+        jsonObj,
+        indent=4,
+        sort_keys=True,
+        separators=(", ", ": "),
+    )
+
+    with open(JSON_DIR, "wb") as f:
+        f.write(jsonStr.encode())
+        f.write(b"\n")
+
+
+def load() -> MyData:
+    with open(JSON_DIR, "rb") as f:
+        jsonStr = f.read().decode()
+
+    jsonObj = json.loads(jsonStr)
+
+    tuple_ = Tuple.restfulJsonDictToTupleWithValidation(jsonObj, MyData)
+    assert isinstance(tuple_, MyData), "tuple_ is not of type MyData"
+    return tuple_
+
+
+if __name__ == "__main__":
+    # Make the data
+    myData = MyData(myName="A good name")
+    myData.myItems.append(MyItem(myBool=False, myStr="store me"))
+    myData.myItems.append(MyItem(myBool=True, myStr="and me too"))
+
+    store(myData)
+
+    myLoadedData = load()
+
+    assert myData.myName == myLoadedData.myName, "myName didn't load correctly"

{vortexpy-6.0.0 → vortexpy-6.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "6.0.0"
+version = "6.0.2"
 license = {text = "MIT"}
 authors = [{name = "Flying Ion Pty Ltd", email = "contact@flyingion.com"}]
 description = "Flying Ion's observable, routable, data serialisation and transport code."
@@ -53,3 +53,17 @@ namespaces = false
 
 [project.entry-points."mypy.plugins"]
 vortex_defer = "vortex.mypy_plugin:plugin"
+
+[tool.pytest.ini_options]
+testpaths = ["vortex"]
+python_files = ["*_test.py"]
+python_functions = ["test*"]
+norecursedirs = ["_trial_temp", "example", "old_fork"]
+markers = [
+    "trial: legacy Twisted Trial *Test.py modules (not collected; run with trial CLI)",
+    "slow: large payload or timing benchmarks",
+    "integration: docker or multi-process integration suites under test-integration/",
+]
+
+[tool.taskipy.tasks]
+test-integrations = "bash -c 'pytest test-integration/ -xvs -m integration'"

{vortexpy-6.0.0 → vortexpy-6.0.2}/vortex/DeferUtil.py

@@ -32,6 +32,7 @@ def callMethodLater(func):
     def wrapper(*args, **kwargs):
         return reactor.callLater(0, func, *args, **kwargs)
 
+    wrapper.__wrapped__ = func
     return wrapper
 
 
@@ -46,7 +47,7 @@ def nonConcurrentMethod(method):
             call.running = False
 
     call.running = False
-
+    call.__wrapped__ = method
     return call
 
 
@@ -60,6 +61,7 @@ def maybeDeferredWrap(funcToWrap):
     def func(*args, **kwargs):
         return maybeDeferred(funcToWrap, *args, **kwargs)
 
+    func.__wrapped__ = funcToWrap
     return func
 
 
@@ -78,6 +80,7 @@ def ensureDeferredWrap(funcToWrap):
     def func(*args, **kwargs):
         return ensureDeferred(funcToWrap(*args, **kwargs))
 
+    func.__wrapped__ = funcToWrap
     return func
 
 
@@ -140,6 +143,7 @@ def vortexInlineCallbacksLogAndConsumeFailure(loggerArg):
             d.addErrback(vortexLogAndConsumeFailure, loggerArg)
             return d
 
+        called.__wrapped__ = funcToWrap
         return called
 
     return wrapper
@@ -153,6 +157,7 @@ def deferToThreadWrapWithLogger(
     loggerArg: logging.Logger,
     consumeError: bool = False,
     checkMainThread: bool = True,
+    logException: bool = True,
 ) -> Callable[[Callable[_P, _R]], Callable[_P, Deferred[_R]]]:
     """Defer To Thread Wrap With Logger
 
@@ -163,6 +168,9 @@ def deferToThreadWrapWithLogger(
     :param checkMainThread: Don't use this parameter, it's only needed during reactor
                 startup when the reactors thread isn't properly set and the check
                 fails.
+    :param logException: When True, thread exceptions are logged at ERROR with a full
+                traceback. When False, the same events are logged at DEBUG with a
+                neutral message so log analysers are not triggered.
 
     :return: A decorator that makes the wrapped callable return a Deferred.
 
@@ -230,11 +238,26 @@ def deferToThreadWrapWithLogger(
                         methodFrame,
                     )
 
+            def handleFailure(failure):
+                if logException:
+                    return vortexLogFailure(
+                        failure, loggerArg, consumeError=consumeError
+                    )
+
+                loggerArg.debug(
+                    "Threaded call failed in %s.%s: %s",
+                    funcToWrap.__module__,
+                    funcToWrap.__qualname__,
+                    failure.getErrorMessage(),
+                )
+                return True if consumeError else failure
+
             d: Deferred[_R] = deferToThread(timedFuncToRun, *args, **kwargs)
             d.addCallback(checkForInlineCallbackYield)
-            d.addErrback(vortexLogFailure, loggerArg, consumeError=consumeError)
+            d.addErrback(handleFailure)
             return d
 
+        func.__wrapped__ = funcToWrap
         return func
 
     return wrapper