vortexpy 4.0.28__tar.gz → 4.1.1__tar.gz

{vortexpy-4.0.28/vortexpy.egg-info → vortexpy-4.1.1}/PKG-INFO

@@ -1,31 +1,9 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.0.28
+Version: 4.1.1
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
-License: MIT License
-        
-        Copyright (c) 2016-2026 Flying Ion Pty Ltd
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-        
+License: MIT
 Project-URL: Homepage, https://flyingion.com
 Project-URL: Repository, https://gitlab.com/flyingion/vortexpy
 Project-URL: Issues, https://gitlab.com/flyingion/vortexpy/-/issues

{vortexpy-4.0.28 → vortexpy-4.1.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.0.28"
-license = {file = "LICENSE"}
+version = "4.1.1"
+license = {text = "MIT"}
 authors = [{name = "Flying Ion Pty Ltd", email = "contact@flyingion.com"}]
 description = "Flying Ion's observable, routable, data serialisation and transport code."
 readme = "README.md"

{vortexpy-4.0.28 → vortexpy-4.1.1}/vortex/PayloadEndpoint.py

@@ -274,7 +274,7 @@ class PayloadEndpoint:
             )
             if self._callableAcceptsAccessControlContext:
                 kwargs["accessControlContext"] = accessControlContext
-            return callable_(**kwargs)
+            return (yield maybeDeferred(callable_, **kwargs))
         else:
             PayloadIO().remove(self)
 

{vortexpy-4.0.28 → vortexpy-4.1.1}/vortex/PayloadEndpointTest.py

@@ -6,6 +6,9 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
+from twisted.internet import reactor
+from twisted.internet.defer import Deferred
+from twisted.internet.defer import inlineCallbacks
 from twisted.trial import unittest
 
 from vortex.Payload import Payload
@@ -19,7 +22,7 @@ class PayloadEndpointPyTestAssignPayload:
         self._ut = unitTest
 
     def process(self, payloadEnvelope: PayloadEnvelope, **kwargs):
-        self._ut.deliveredPayload = payloadEnvelope
+        self._ut.deliveredPayloadEnvelope = payloadEnvelope
 
 
 class PayloadEndpointPyTest(unittest.TestCase):
@@ -28,46 +31,66 @@ class PayloadEndpointPyTest(unittest.TestCase):
 
         self.deliveredPayloadEnvelope = None
 
-    def _testBuild(self, plFilt, epFilt):
+    @inlineCallbacks
+    def _flushReactor(self):
+        # PayloadIO schedules via callLater(0); PayloadEndpoint.process yields
+        # maybeDeferred — allow a few reactor turns to finish delivery.
+        for _ in range(3):
+            d = Deferred()
+            reactor.callLater(0, d.callback, None)
+            yield d
+
+    def _newPayload(self, plFilt: dict) -> Payload:
         payload = Payload()
         payload.filt.update(plFilt)
         for x in range(6):
             payload.filt["%s" % x] = x
+        return payload
 
-        def processPayload(payloadEnvelope: PayloadEnvelope, **kwargs):
-            self.deliveredPayloadEnvelope = payloadEnvelope
-
-        self._keepFuncInScope = processPayload
-
-        PayloadEndpoint(epFilt, processPayload, requiredPermissions=frozenset())
-
+    def _processEnvelope(self, payload: Payload) -> None:
+        # Build envelope without Payload.makePayloadEnvelope() — that path
+        # forbids the reactor thread (blocking encode).
         PayloadIO().process(
-            payloadEnvelope=payload.makePayloadEnvelope(),
+            payloadEnvelope=PayloadEnvelope(filt=payload.filt),
             vortexUuid="test",
             vortexName="test",
             vortexSession=None,
             sendResponse=lambda x: x,
         )
 
+    def _registerAndProcess(self, plFilt, epFilt) -> Payload:
+        payload = self._newPayload(plFilt)
+
+        def processPayload(payloadEnvelope: PayloadEnvelope, **kwargs):
+            self.deliveredPayloadEnvelope = payloadEnvelope
+
+        self._keepFuncInScope = processPayload
+
+        PayloadEndpoint(epFilt, processPayload, requiredPermissions=frozenset())
+        self._processEnvelope(payload)
         return payload
 
+    @inlineCallbacks
     def testFiltMatches(self):
         plFilt = {"key": "unittest", "This matches": 555}
         epFilt = {"key": "unittest", "This matches": 555}
 
-        payload = self._testBuild(plFilt, epFilt)
+        payload = self._registerAndProcess(plFilt, epFilt)
+        yield self._flushReactor()
 
         self.assertEqual(
-            payload,
-            self.deliveredPayloadEnvelope,
+            payload.filt,
+            self.deliveredPayloadEnvelope.filt,
             "PayloadIO/PayloadEndpoint delivery error",
         )
 
+    @inlineCallbacks
     def testFiltValueUnmatched(self):
         plFilt = {"key": "unittest", "This matches": 555}
         epFilt = {"key": "unittest", "This matches": 0}
 
-        self._testBuild(plFilt, epFilt)
+        self._registerAndProcess(plFilt, epFilt)
+        yield self._flushReactor()
 
         self.assertEqual(
             self.deliveredPayloadEnvelope,
@@ -75,11 +98,13 @@ class PayloadEndpointPyTest(unittest.TestCase):
             "PayloadIO/PayloadEndpoint unmatched value test error",
         )
 
+    @inlineCallbacks
     def testFiltKeyUnmatched(self):
         plFilt = {"key": "unittest", "This matches": 555}
         epFilt = {"key": "unittest", "This doesnt matches": 555}
 
-        self._testBuild(plFilt, epFilt)
+        self._registerAndProcess(plFilt, epFilt)
+        yield self._flushReactor()
 
         self.assertEqual(
             self.deliveredPayloadEnvelope,
@@ -87,11 +112,10 @@ class PayloadEndpointPyTest(unittest.TestCase):
             "PayloadIO/PayloadEndpoint unmatched value test error",
         )
 
+    @inlineCallbacks
     def testFunctionGoesOutOfScope(self):
         filt = {"key": "unittest", "This matches": 555}
-
-        payload = Payload()
-        payload.filt = filt
+        payload = self._newPayload(filt)
 
         def subScope():
             def outOfScopeFunc(
@@ -99,15 +123,12 @@ class PayloadEndpointPyTest(unittest.TestCase):
             ):
                 self.deliveredPayloadEnvelope = payloadEnvelope
 
-            PayloadEndpoint(filt, outOfScopeFunc, requiredPermissions=frozenset())
+            PayloadEndpoint(
+                filt, outOfScopeFunc, requiredPermissions=frozenset()
+            )
 
-        PayloadIO().process(
-            payloadEnvelope=payload.makePayloadEnvelope(),
-            vortexUuid="test",
-            vortexName="test",
-            vortexSession=None,
-            sendResponse=lambda x: x,
-        )
+        self._processEnvelope(payload)
+        yield self._flushReactor()
 
         self.assertEqual(
             self.deliveredPayloadEnvelope,
@@ -115,23 +136,19 @@ class PayloadEndpointPyTest(unittest.TestCase):
             "PayloadIO/PayloadEndpoint unmatched value test error",
         )
 
+    @inlineCallbacks
     def testClassGoesOutOdScope(self):
         filt = {"key": "unittest", "This matches": 555}
-
-        payload = Payload()
-        payload.filt = filt
+        payload = self._newPayload(filt)
 
         def subScope():
             inst = PayloadEndpointPyTestAssignPayload(self)
-            PayloadEndpoint(filt, inst.process, requiredPermissions=frozenset())
+            PayloadEndpoint(
+                filt, inst.process, requiredPermissions=frozenset()
+            )
 
-        PayloadIO().process(
-            payloadEnvelope=payload.makePayloadEnvelope(),
-            vortexUuid="test",
-            vortexName="test",
-            vortexSession=None,
-            sendResponse=lambda x: x,
-        )
+        self._processEnvelope(payload)
+        yield self._flushReactor()
 
         self.assertEqual(
             self.deliveredPayloadEnvelope,
@@ -139,25 +156,19 @@ class PayloadEndpointPyTest(unittest.TestCase):
             "PayloadIO/PayloadEndpoint unmatched value test error",
         )
 
+    @inlineCallbacks
     def testClassStaysInScope(self):
         filt = {"key": "unittest", "This matches": 555}
-
-        payload = Payload()
-        payload.filt = filt
+        payload = self._newPayload(filt)
 
         inst = PayloadEndpointPyTestAssignPayload(self)
         PayloadEndpoint(filt, inst.process, requiredPermissions=frozenset())
 
-        PayloadIO().process(
-            payloadEnvelope=payload.makePayloadEnvelope(),
-            vortexUuid="test",
-            vortexName="test",
-            vortexSession=None,
-            sendResponse=lambda x: x,
-        )
+        self._processEnvelope(payload)
+        yield self._flushReactor()
 
         self.assertEqual(
-            self.deliveredPayloadEnvelope,
-            payload,
+            payload.filt,
+            self.deliveredPayloadEnvelope.filt,
             "PayloadIO/PayloadEndpoint unmatched value test error",
         )

{vortexpy-4.0.28 → vortexpy-4.1.1}/vortex/Tuple.py

@@ -595,6 +595,23 @@ class Tuple(Jsonable, _TupleToPlainJsonMixin, _TupleToSqlaJsonMixin):
     def tupleFieldNames(cls) -> List[str]:
         return cls.__fieldNames__
 
+    @classmethod
+    def tupleJsonSchema(cls) -> "JsonSchemaNodeTuple":
+        """Tuple JSON Schema
+
+        Build a typed Draft 2020-12 subset schema tree from this tuple's
+        ``TupleField`` metadata.
+
+        :return: Root ``JsonSchemaNodeTuple``. Call ``buildJsonSchemaDict()``
+            for Draft 2020-12 JSON Schema keys, or ``tupleToRestfulJsonDict()``
+            for Vortex restful JSON.
+        """
+        from vortex.tuple_json_schema.tuple_json_schema_builder import (
+            TupleJsonSchemaBuilder,
+        )
+
+        return TupleJsonSchemaBuilder.buildJsonSchema(cls)
+
     @classmethod
     def tupleName(cls):  # DEPRECIATED
         return cls.__tupleType__

{vortexpy-4.0.28 → vortexpy-4.1.1}/vortex/VortexFactory.py

@@ -446,8 +446,14 @@ class VortexFactory:
                 yield deferLater(reactor, 0.05, lambda: None)
 
         while cls.__listeningPorts:
-            cls.__listeningPorts.pop().stopListening()
-            yield deferLater(reactor, 0.05, lambda: None)
+            stopDeferred = cls.__listeningPorts.pop().stopListening()
+            if stopDeferred is not None:
+                yield stopDeferred
+
+        # Let Twisted finish unregistering closed ports from the reactor
+        # before before-shutdown returns — avoids epoll Bad file descriptor
+        # spam when other before-shutdown handlers close sockets next.
+        yield deferLater(reactor, 0.05, lambda: None)
 
         cls.__vortexInfoState = _VortexFactoryVortexInfo()
 

vortexpy-4.1.1/vortex/__init__.py

@@ -0,0 +1,9 @@
+# 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
+
+__version__ = '4.1.1'

{vortexpy-4.0.28 → vortexpy-4.1.1}/vortex/event_bus/TupleChangeEventBus.py

@@ -163,6 +163,29 @@ class TupleChangeEventBus:
 
         self._weakObserversBySelectorName[eventName].add(observer)
 
+    def removeObserver(
+        self,
+        observer: TupleChangeEventBusObserverABC,
+        eventNameOrClass: Optional[
+            Union[
+                str,
+                Type[TupleChangeEventABC],
+                TupleChangeEventABC,
+            ]
+        ] = None,
+    ) -> None:
+        assert isinstance(
+            observer, TupleChangeEventBusObserverABC
+        ), "observer must be a TupleChangeEventBusObserverABC"
+
+        if eventNameOrClass is None:
+            self._weakObserversForAllTupleChangeEventABCNames.discard(observer)
+            return
+
+        eventName = self._nameFromEvent(eventNameOrClass)
+
+        self._weakObserversBySelectorName[eventName].discard(observer)
+
     # noinspection PyMethodMayBeStatic
     def _nameFromEvent(
         self,

vortexpy-4.1.1/vortex/tuple_json_schema/__init__.py

@@ -0,0 +1,18 @@
+# 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
+
+"""Tuple JSON Schema — typed Vortex tuples for Draft 2020-12 subset schemas.
+
+Import from submodules::
+
+    from vortex.tuple_json_schema.json_schema_node_tuple import JsonSchemaNodeTuple
+    from vortex.tuple_json_schema.tuple_json_schema_builder import (
+        TupleJsonSchemaBuilder,
+    )
+    from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_STRING
+"""

vortexpy-4.1.1/vortex/tuple_json_schema/constants.py

@@ -0,0 +1,35 @@
+# 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
+
+"""JSON Schema string constants for Draft 2020-12 subset."""
+
+JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema"
+
+JSON_SCHEMA_KEY_SCHEMA = "$schema"
+JSON_SCHEMA_KEY_DEFS = "$defs"
+JSON_SCHEMA_KEY_REF = "$ref"
+JSON_SCHEMA_KEY_TYPE = "type"
+JSON_SCHEMA_KEY_TITLE = "title"
+JSON_SCHEMA_KEY_PROPERTIES = "properties"
+JSON_SCHEMA_KEY_REQUIRED = "required"
+JSON_SCHEMA_KEY_ITEMS = "items"
+JSON_SCHEMA_KEY_FORMAT = "format"
+JSON_SCHEMA_KEY_CONTENT_ENCODING = "contentEncoding"
+JSON_SCHEMA_KEY_DESCRIPTION = "description"
+
+JSON_SCHEMA_TYPE_OBJECT = "object"
+JSON_SCHEMA_TYPE_STRING = "string"
+JSON_SCHEMA_TYPE_INTEGER = "integer"
+JSON_SCHEMA_TYPE_NUMBER = "number"
+JSON_SCHEMA_TYPE_BOOLEAN = "boolean"
+JSON_SCHEMA_TYPE_ARRAY = "array"
+
+JSON_SCHEMA_FORMAT_DATE_TIME = "date-time"
+JSON_SCHEMA_CONTENT_ENCODING_BINARY = "binary"
+
+JSON_SCHEMA_DEFS_REF_PREFIX = f"#/{JSON_SCHEMA_KEY_DEFS}/"

vortexpy-4.1.1/vortex/tuple_json_schema/json_schema_node_tuple.py

@@ -0,0 +1,99 @@
+# 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
+
+"""JSON Schema node as a Vortex tuple (Draft 2020-12 subset)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from vortex.Tuple import Tuple
+from vortex.Tuple import TupleField
+from vortex.Tuple import addTupleType
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_CONTENT_ENCODING
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_DEFS
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_DESCRIPTION
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_FORMAT
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_ITEMS
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_PROPERTIES
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_REF
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_REQUIRED
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_SCHEMA
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_TITLE
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_KEY_TYPE
+
+
+@addTupleType
+class JsonSchemaNodeTuple(Tuple):
+    """JSON Schema Node Tuple
+
+    Typed Draft 2020-12 subset node. Application code uses this tuple;
+    call ``buildJsonSchemaDict()`` only at a boundary that needs raw JSON Schema
+    (``$schema`` / ``$ref`` / ``$defs`` keys). Prefer
+    ``tupleToRestfulJsonDict()`` when serialising as a normal Vortex tuple.
+    """
+
+    __tupleType__ = "flyingion.vortex.JsonSchemaNodeTuple"
+
+    schemaUri: str | None = TupleField(None, typingType=str | None)
+    schemaType: str | None = TupleField(None, typingType=str | None)
+    title: str | None = TupleField(None, typingType=str | None)
+    description: str | None = TupleField(None, typingType=str | None)
+    format: str | None = TupleField(None, typingType=str | None)
+    contentEncoding: str | None = TupleField(None, typingType=str | None)
+    ref: str | None = TupleField(None, typingType=str | None)
+    items: JsonSchemaNodeTuple | None = TupleField(None)
+    properties: dict[str, JsonSchemaNodeTuple] | None = TupleField(None)
+    required: list[str] | None = TupleField(None, typingType=list[str] | None)
+    defs: dict[str, JsonSchemaNodeTuple] | None = TupleField(None)
+
+    def buildJsonSchemaDict(self) -> dict[str, Any]:
+        """Build JSON Schema Dict
+
+        Emit a Draft 2020-12 subset dict with JSON Schema keys
+        (``$schema``, ``$ref``, ``$defs``, ``type``, …).
+
+        :return: JSON-serialisable schema dict.
+        """
+        out: dict[str, Any] = {}
+        if self.schemaUri is not None:
+            out[JSON_SCHEMA_KEY_SCHEMA] = self.schemaUri
+        if self.schemaType is not None:
+            out[JSON_SCHEMA_KEY_TYPE] = self.schemaType
+        if self.title is not None:
+            out[JSON_SCHEMA_KEY_TITLE] = self.title
+        if self.description is not None:
+            out[JSON_SCHEMA_KEY_DESCRIPTION] = self.description
+        if self.format is not None:
+            out[JSON_SCHEMA_KEY_FORMAT] = self.format
+        if self.contentEncoding is not None:
+            out[JSON_SCHEMA_KEY_CONTENT_ENCODING] = self.contentEncoding
+        if self.ref is not None:
+            out[JSON_SCHEMA_KEY_REF] = self.ref
+        if self.items is not None:
+            out[JSON_SCHEMA_KEY_ITEMS] = self.items.buildJsonSchemaDict()
+        if self.properties is not None:
+            out[JSON_SCHEMA_KEY_PROPERTIES] = {
+                name: node.buildJsonSchemaDict()
+                for name, node in self.properties.items()
+            }
+        if self.required is not None:
+            out[JSON_SCHEMA_KEY_REQUIRED] = list(self.required)
+        if self.defs is not None:
+            out[JSON_SCHEMA_KEY_DEFS] = {
+                name: node.buildJsonSchemaDict()
+                for name, node in self.defs.items()
+            }
+        return out
+
+
+JsonSchemaNodeTuple.items.typingType = JsonSchemaNodeTuple | None
+JsonSchemaNodeTuple.properties.typingType = (
+    dict[str, JsonSchemaNodeTuple] | None
+)
+JsonSchemaNodeTuple.defs.typingType = dict[str, JsonSchemaNodeTuple] | None