vortexpy 4.0.29__tar.gz → 4.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.0.29
+Version: 4.1.2
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-4.0.29 → vortexpy-4.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.0.29"
+version = "4.1.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."

{vortexpy-4.0.29 → vortexpy-4.1.2}/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.29 → vortexpy-4.1.2}/vortex/TupleRestful.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import TYPE_CHECKING, Annotated, Any, NamedTuple, Optional, Type
 
-from typing import get_args
+from typing import Union, get_args
 from typing import get_origin
 from typing import get_type_hints
 
@@ -256,6 +256,24 @@ class TupleRestfulConverter:
 
         return True
 
+    @classmethod
+    def _nestedTupleTypeFromHint(cls, typeHint: Any) -> Any | None:
+        """Return nested tuple class for a field hint, including ``X | None`` unions."""
+        if hasattr(typeHint, "__tupleType__"):
+            return typeHint
+
+        unionArgs = get_args(typeHint)
+        if not unionArgs:
+            return None
+
+        for unionArg in unionArgs:
+            if unionArg is type(None):
+                continue
+            if hasattr(unionArg, "__tupleType__"):
+                return unionArg
+
+        return None
+
     @classmethod
     def _checkType(
         cls,
@@ -284,6 +302,9 @@ class TupleRestfulConverter:
             if hasattr(typeHint, "__tupleType__"):
                 return None
 
+            if cls._nestedTupleTypeFromHint(typeHint) is not None:
+                return None
+
         if type(value) in get_args(typeHint):
             if validator:
                 try:
@@ -425,6 +446,16 @@ class TupleRestfulConverter:
                 cls._prefixValidationErrors(child.errors, field_path),
             )
 
+        nestedTupleType = cls._nestedTupleTypeFromHint(typeHint)
+        if nestedTupleType is not None and nestedTupleType is not typeHint:
+            child = cls.restfulJsonDictToTupleWithValidationResult(
+                value, nestedTupleType
+            )
+            return _ConvertResult(
+                child.tuple_,
+                cls._prefixValidationErrors(child.errors, field_path),
+            )
+
         if not get_args(typeHint):
             return _ConvertResult(
                 _UNSET,

vortexpy-4.1.2/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.2'

vortexpy-4.1.2/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.2/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.2/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__ = "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

vortexpy-4.1.2/vortex/tuple_json_schema/tuple_json_schema_builder.py

@@ -0,0 +1,225 @@
+# 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
+
+"""Build a ``JsonSchemaNodeTuple`` tree from ``TupleField`` metadata."""
+
+from __future__ import annotations
+
+import types
+from datetime import datetime
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Union
+from typing import get_args
+from typing import get_origin
+
+from vortex.Tuple import Tuple
+from vortex.Tuple import TupleField
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_CONTENT_ENCODING_BINARY
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_DEFS_REF_PREFIX
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_DRAFT_2020_12
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_FORMAT_DATE_TIME
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_ARRAY
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_BOOLEAN
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_INTEGER
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_NUMBER
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_OBJECT
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_STRING
+from vortex.tuple_json_schema.json_schema_node_tuple import JsonSchemaNodeTuple
+
+
+class TupleJsonSchemaBuilder:
+    """Tuple JSON Schema Builder
+
+    Builds a ``JsonSchemaNodeTuple`` tree from a ``Tuple`` subclass using
+    ``TupleField.typingType``, ``defaultValue``, and ``comment``.
+    """
+
+    @classmethod
+    def buildJsonSchema(cls, tupleCls: type[Tuple]) -> JsonSchemaNodeTuple:
+        """Build JSON Schema Node
+
+        Produce a typed schema tree for ``tupleCls`` from its ``TupleField``
+        entries.
+
+        :param tupleCls: Registered ``Tuple`` subclass to describe.
+        :return: Root ``JsonSchemaNodeTuple`` (call ``buildJsonSchemaDict()``
+            for Draft 2020-12 JSON Schema keys).
+        """
+        builder = cls()
+        return builder._buildRoot(tupleCls)
+
+    def __init__(self) -> None:
+        self._defs: dict[str, JsonSchemaNodeTuple] = {}
+        self._building: set[str] = set()
+
+    def _buildRoot(self, tupleCls: type[Tuple]) -> JsonSchemaNodeTuple:
+        # Build object schema for the root tuple type
+        objectSchema = self._buildObjectSchema(tupleCls)
+        rootTupleType = tupleCls.tupleType()
+
+        # Self-references emit $ref into defs; place the root object schema there
+        # (without draft URI or nested defs).
+        if rootTupleType in self._defs:
+            defsCopy = objectSchema.tupleClone(deep=True)
+            defsCopy.schemaUri = None
+            defsCopy.defs = None
+            self._defs[rootTupleType] = defsCopy
+
+        # Assemble root document with draft URI and optional defs
+        objectSchema.schemaUri = JSON_SCHEMA_DRAFT_2020_12
+        if self._defs:
+            objectSchema.defs = dict(self._defs)
+
+        return objectSchema
+
+    def _buildObjectSchema(self, tupleCls: type[Tuple]) -> JsonSchemaNodeTuple:
+        tupleTypeName = tupleCls.tupleType()
+        self._building.add(tupleTypeName)
+
+        # Map each TupleField to a property schema and required list
+        properties: dict[str, JsonSchemaNodeTuple] = {}
+        required: list[str] = []
+        for fieldName in tupleCls.tupleFieldNames():
+            field = getattr(tupleCls, fieldName, None)
+            if not isinstance(field, TupleField):
+                continue
+
+            propSchema = self._schemaForTypingType(field.typingType)
+            if field.comment:
+                propSchema.description = field.comment
+
+            properties[fieldName] = propSchema
+            if not self._isOptionalField(field):
+                required.append(fieldName)
+
+        self._building.discard(tupleTypeName)
+
+        # Assemble object schema
+        objectSchema = JsonSchemaNodeTuple(
+            schemaType=JSON_SCHEMA_TYPE_OBJECT,
+            title=tupleTypeName,
+            properties=properties,
+        )
+        if required:
+            objectSchema.required = required
+
+        return objectSchema
+
+    def _isOptionalField(self, field: TupleField) -> bool:
+        if field.defaultValue is None:
+            return True
+        return self._typingIncludesNone(field.typingType)
+
+    def _typingIncludesNone(self, typingType: Any) -> bool:
+        if typingType is None:
+            return False
+
+        origin = get_origin(typingType)
+        if origin is Union or origin is types.UnionType:
+            return type(None) in get_args(typingType)
+        return False
+
+    def _unwrapOptional(self, typingType: Any) -> Any:
+        origin = get_origin(typingType)
+        if origin is not Union and origin is not types.UnionType:
+            return typingType
+
+        nonNoneArgs = [
+            arg for arg in get_args(typingType) if arg is not type(None)
+        ]
+        if len(nonNoneArgs) == 1:
+            return nonNoneArgs[0]
+
+        if not nonNoneArgs:
+            return typingType
+
+        raise NotImplementedError(
+            f"Unsupported multi-member Union for JSON Schema: {typingType!r}"
+        )
+
+    def _schemaForTypingType(self, typingType: Any) -> JsonSchemaNodeTuple:
+        # Missing typingType maps to string (TupleField default)
+        if typingType is None:
+            return JsonSchemaNodeTuple(schemaType=JSON_SCHEMA_TYPE_STRING)
+
+        # Scalar and built-in types
+        typingType = self._unwrapOptional(typingType)
+        if typingType is str:
+            return JsonSchemaNodeTuple(schemaType=JSON_SCHEMA_TYPE_STRING)
+
+        if typingType is int:
+            return JsonSchemaNodeTuple(schemaType=JSON_SCHEMA_TYPE_INTEGER)
+
+        if typingType is float:
+            return JsonSchemaNodeTuple(schemaType=JSON_SCHEMA_TYPE_NUMBER)
+
+        if typingType is bool:
+            return JsonSchemaNodeTuple(schemaType=JSON_SCHEMA_TYPE_BOOLEAN)
+
+        if typingType is datetime:
+            return JsonSchemaNodeTuple(
+                schemaType=JSON_SCHEMA_TYPE_STRING,
+                format=JSON_SCHEMA_FORMAT_DATE_TIME,
+            )
+
+        if typingType in (bytes, bytearray):
+            return JsonSchemaNodeTuple(
+                schemaType=JSON_SCHEMA_TYPE_STRING,
+                contentEncoding=JSON_SCHEMA_CONTENT_ENCODING_BINARY,
+            )
+
+        # Collections
+        origin = get_origin(typingType)
+        if origin in (list, List) or typingType is list:
+            args = get_args(typingType)
+            itemType = args[0] if args else None
+            return JsonSchemaNodeTuple(
+                schemaType=JSON_SCHEMA_TYPE_ARRAY,
+                items=self._schemaForTypingType(itemType),
+            )
+
+        if origin in (dict, Dict) or typingType is dict:
+            return JsonSchemaNodeTuple(schemaType=JSON_SCHEMA_TYPE_OBJECT)
+
+        # Nested Tuple subclasses
+        if self._isTupleSubclass(typingType):
+            return self._refForTuple(typingType)
+
+        raise NotImplementedError(
+            f"Unsupported TupleField typingType for JSON Schema: {typingType!r}"
+        )
+
+    def _isTupleSubclass(self, typingType: Any) -> bool:
+        return (
+            isinstance(typingType, type)
+            and issubclass(typingType, Tuple)
+            and typingType is not Tuple
+        )
+
+    def _refForTuple(self, tupleCls: type[Tuple]) -> JsonSchemaNodeTuple:
+        tupleTypeName = tupleCls.tupleType()
+        ref = JsonSchemaNodeTuple(
+            ref=f"{JSON_SCHEMA_DEFS_REF_PREFIX}{tupleTypeName}"
+        )
+
+        # Cycle: emit $ref only; outer build places the object in defs
+        if tupleTypeName in self._building:
+            if tupleTypeName not in self._defs:
+                self._defs[tupleTypeName] = JsonSchemaNodeTuple(
+                    schemaType=JSON_SCHEMA_TYPE_OBJECT,
+                    title=tupleTypeName,
+                    properties={},
+                )
+            return ref
+
+        if tupleTypeName not in self._defs:
+            self._defs[tupleTypeName] = self._buildObjectSchema(tupleCls)
+
+        return ref

vortexpy-4.1.2/vortex/tuple_json_schema/tuple_json_schema_test.py

@@ -0,0 +1,257 @@
+# 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.trial import unittest
+
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_CONTENT_ENCODING_BINARY
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_DEFS_REF_PREFIX
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_DRAFT_2020_12
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_FORMAT_DATE_TIME
+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
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_ARRAY
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_BOOLEAN
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_INTEGER
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_NUMBER
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_OBJECT
+from vortex.tuple_json_schema.constants import JSON_SCHEMA_TYPE_STRING
+from vortex.tuple_json_schema.json_schema_node_tuple import JsonSchemaNodeTuple
+from vortex.tuple_json_schema.tuple_json_schema_test_tuples import (
+    JsonSchemaBareListTuple,
+)
+from vortex.tuple_json_schema.tuple_json_schema_test_tuples import (
+    JsonSchemaNestedTuple,
+)
+from vortex.tuple_json_schema.tuple_json_schema_test_tuples import (
+    JsonSchemaParentTuple,
+)
+from vortex.tuple_json_schema.tuple_json_schema_test_tuples import (
+    JsonSchemaScalarTuple,
+)
+from vortex.tuple_json_schema.tuple_json_schema_test_tuples import (
+    JsonSchemaSelfRefTuple,
+)
+
+
+class TupleJsonSchemaTest(unittest.TestCase):
+    def testScalarsDatetimeAndOptional(self):
+        schema = JsonSchemaScalarTuple.tupleJsonSchema()
+        self.assertIsInstance(schema, JsonSchemaNodeTuple)
+
+        self.assertEqual(schema.schemaUri, JSON_SCHEMA_DRAFT_2020_12)
+        self.assertEqual(schema.schemaType, JSON_SCHEMA_TYPE_OBJECT)
+        self.assertEqual(schema.title, JsonSchemaScalarTuple.tupleType())
+        assert schema.properties is not None, (
+            "JsonSchemaScalarTuple schema.properties must be set"
+        )
+
+        self.assertEqual(
+            schema.properties["aString"].schemaType, JSON_SCHEMA_TYPE_STRING
+        )
+        self.assertEqual(
+            schema.properties["aInt"].schemaType, JSON_SCHEMA_TYPE_INTEGER
+        )
+        self.assertEqual(
+            schema.properties["aFloat"].schemaType, JSON_SCHEMA_TYPE_NUMBER
+        )
+        self.assertEqual(
+            schema.properties["aBool"].schemaType, JSON_SCHEMA_TYPE_BOOLEAN
+        )
+        self.assertEqual(
+            schema.properties["aDate"].schemaType, JSON_SCHEMA_TYPE_STRING
+        )
+        self.assertEqual(
+            schema.properties["aDate"].format, JSON_SCHEMA_FORMAT_DATE_TIME
+        )
+        self.assertEqual(
+            schema.properties["aOptional"].schemaType, JSON_SCHEMA_TYPE_STRING
+        )
+        self.assertEqual(
+            schema.properties["aBytes"].schemaType, JSON_SCHEMA_TYPE_STRING
+        )
+        self.assertEqual(
+            schema.properties["aBytes"].contentEncoding,
+            JSON_SCHEMA_CONTENT_ENCODING_BINARY,
+        )
+        self.assertEqual(
+            schema.properties["aDict"].schemaType, JSON_SCHEMA_TYPE_OBJECT
+        )
+
+        assert schema.required is not None, (
+            "JsonSchemaScalarTuple schema.required must be set"
+        )
+        self.assertIn("aString", schema.required)
+        self.assertIn("aDate", schema.required)
+        self.assertNotIn("aOptional", schema.required)
+
+    def testMissingTypingTypeFallsBackToString(self):
+        schema = JsonSchemaScalarTuple.tupleJsonSchema()
+        assert schema.properties is not None, (
+            "JsonSchemaScalarTuple schema.properties must be set for "
+            "missing typingType test"
+        )
+        self.assertEqual(
+            schema.properties["aMissingTyping"].schemaType,
+            JSON_SCHEMA_TYPE_STRING,
+        )
+
+    def testCommentBecomesDescription(self):
+        schema = JsonSchemaScalarTuple.tupleJsonSchema()
+        assert schema.properties is not None, (
+            "JsonSchemaScalarTuple schema.properties must be set for "
+            "comment description test"
+        )
+        aComment = schema.properties["aComment"]
+        self.assertEqual(aComment.description, "Field with a description")
+        self.assertEqual(aComment.schemaType, JSON_SCHEMA_TYPE_STRING)
+
+    def testNestedTupleDefsAndRef(self):
+        schema = JsonSchemaParentTuple.tupleJsonSchema()
+        nestedType = JsonSchemaNestedTuple.tupleType()
+        assert schema.properties is not None, (
+            "JsonSchemaParentTuple schema.properties must be set"
+        )
+        assert schema.defs is not None, (
+            "JsonSchemaParentTuple schema.defs must be set for nested tuple"
+        )
+
+        self.assertEqual(
+            schema.properties["child"].ref,
+            f"{JSON_SCHEMA_DEFS_REF_PREFIX}{nestedType}",
+        )
+        self.assertIn(nestedType, schema.defs)
+        nestedSchema = schema.defs[nestedType]
+        self.assertEqual(nestedSchema.schemaType, JSON_SCHEMA_TYPE_OBJECT)
+        self.assertEqual(nestedSchema.title, nestedType)
+        assert nestedSchema.properties is not None, (
+            "nested JsonSchemaNestedTuple defs entry properties must be set"
+        )
+        self.assertEqual(
+            nestedSchema.properties["nestedInt"].schemaType,
+            JSON_SCHEMA_TYPE_INTEGER,
+        )
+
+    def testListOfNestedTuple(self):
+        schema = JsonSchemaParentTuple.tupleJsonSchema()
+        nestedType = JsonSchemaNestedTuple.tupleType()
+        assert schema.properties is not None, (
+            "JsonSchemaParentTuple schema.properties must be set for list test"
+        )
+        children = schema.properties["children"]
+
+        self.assertEqual(children.schemaType, JSON_SCHEMA_TYPE_ARRAY)
+        assert children.items is not None, (
+            "JsonSchemaParentTuple children.items must be set"
+        )
+        self.assertEqual(
+            children.items.ref, f"{JSON_SCHEMA_DEFS_REF_PREFIX}{nestedType}"
+        )
+
+    def testBareListTypingTypeIsArray(self):
+        schema = JsonSchemaBareListTuple.tupleJsonSchema()
+        assert schema.properties is not None, (
+            "JsonSchemaBareListTuple schema.properties must be set"
+        )
+        items = schema.properties["items"]
+
+        self.assertEqual(items.schemaType, JSON_SCHEMA_TYPE_ARRAY)
+        assert items.items is not None, (
+            "JsonSchemaBareListTuple items.items must be set"
+        )
+        self.assertEqual(items.items.schemaType, JSON_SCHEMA_TYPE_STRING)
+
+    def testSelfReferenceDoesNotInfiniteLoop(self):
+        schema = JsonSchemaSelfRefTuple.tupleJsonSchema()
+        selfType = JsonSchemaSelfRefTuple.tupleType()
+        assert schema.properties is not None, (
+            "JsonSchemaSelfRefTuple schema.properties must be set"
+        )
+        assert schema.defs is not None, (
+            "JsonSchemaSelfRefTuple schema.defs must be set for self-ref"
+        )
+
+        self.assertEqual(
+            schema.properties["parent"].ref,
+            f"{JSON_SCHEMA_DEFS_REF_PREFIX}{selfType}",
+        )
+        self.assertIn(selfType, schema.defs)
+        selfDefs = schema.defs[selfType]
+        self.assertEqual(selfDefs.schemaType, JSON_SCHEMA_TYPE_OBJECT)
+        assert selfDefs.properties is not None, (
+            "self-ref defs entry properties must be set"
+        )
+        self.assertEqual(
+            selfDefs.properties["parent"].ref,
+            f"{JSON_SCHEMA_DEFS_REF_PREFIX}{selfType}",
+        )
+        self.assertNotIn("parent", schema.required or [])
+
+    def testBuildJsonSchemaDictKeys(self):
+        schema = JsonSchemaScalarTuple.tupleJsonSchema()
+        schemaDict = schema.buildJsonSchemaDict()
+
+        self.assertEqual(
+            schemaDict[JSON_SCHEMA_KEY_SCHEMA], JSON_SCHEMA_DRAFT_2020_12
+        )
+        self.assertEqual(
+            schemaDict[JSON_SCHEMA_KEY_TYPE], JSON_SCHEMA_TYPE_OBJECT
+        )
+        self.assertEqual(
+            schemaDict[JSON_SCHEMA_KEY_TITLE],
+            JsonSchemaScalarTuple.tupleType(),
+        )
+        properties = schemaDict[JSON_SCHEMA_KEY_PROPERTIES]
+        self.assertEqual(
+            properties["aDate"],
+            {
+                JSON_SCHEMA_KEY_TYPE: JSON_SCHEMA_TYPE_STRING,
+                JSON_SCHEMA_KEY_FORMAT: JSON_SCHEMA_FORMAT_DATE_TIME,
+            },
+        )
+        self.assertEqual(
+            properties["aComment"][JSON_SCHEMA_KEY_DESCRIPTION],
+            "Field with a description",
+        )
+        self.assertIn("aString", schemaDict[JSON_SCHEMA_KEY_REQUIRED])
+
+    def testBuildJsonSchemaDictNestedRef(self):
+        schema = JsonSchemaParentTuple.tupleJsonSchema()
+        schemaDict = schema.buildJsonSchemaDict()
+        nestedType = JsonSchemaNestedTuple.tupleType()
+
+        self.assertEqual(
+            schemaDict[JSON_SCHEMA_KEY_PROPERTIES]["child"],
+            {
+                JSON_SCHEMA_KEY_REF: (
+                    f"{JSON_SCHEMA_DEFS_REF_PREFIX}{nestedType}"
+                )
+            },
+        )
+        self.assertIn(nestedType, schemaDict[JSON_SCHEMA_KEY_DEFS])
+        self.assertEqual(
+            schemaDict[JSON_SCHEMA_KEY_PROPERTIES]["children"][
+                JSON_SCHEMA_KEY_ITEMS
+            ],
+            {
+                JSON_SCHEMA_KEY_REF: (
+                    f"{JSON_SCHEMA_DEFS_REF_PREFIX}{nestedType}"
+                )
+            },
+        )
+        self.assertEqual(
+            schemaDict[JSON_SCHEMA_KEY_DEFS][nestedType][JSON_SCHEMA_KEY_TYPE],
+            JSON_SCHEMA_TYPE_OBJECT,
+        )

vortexpy-4.1.2/vortex/tuple_json_schema/tuple_json_schema_test_tuples.py

@@ -0,0 +1,69 @@
+# 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
+
+"""Fixture tuples for ``tuple_json_schema_test``."""
+
+from datetime import datetime
+from datetime import timezone
+
+from vortex.Tuple import Tuple
+from vortex.Tuple import TupleField
+from vortex.Tuple import addTupleType
+
+
+@addTupleType
+class JsonSchemaNestedTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonSchemaNestedTuple"
+    nestedInt = TupleField(defaultValue=0, typingType=int)
+
+
+@addTupleType
+class JsonSchemaScalarTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonSchemaScalarTuple"
+    aString = TupleField(defaultValue="", typingType=str)
+    aInt = TupleField(defaultValue=0, typingType=int)
+    aFloat = TupleField(defaultValue=0.0, typingType=float)
+    aBool = TupleField(defaultValue=False, typingType=bool)
+    aDate = TupleField(
+        defaultValue=datetime(2020, 1, 1, tzinfo=timezone.utc),
+        typingType=datetime,
+    )
+    aOptional = TupleField(typingType=str | None)
+    aBytes = TupleField(defaultValue=b"", typingType=bytes)
+    aDict = TupleField(defaultValue={}, typingType=dict)
+    aComment = TupleField(
+        defaultValue="",
+        typingType=str,
+        comment="Field with a description",
+    )
+    aMissingTyping = TupleField(defaultValue="")
+
+
+@addTupleType
+class JsonSchemaParentTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonSchemaParentTuple"
+    child = TupleField(typingType=JsonSchemaNestedTuple)
+    children = TupleField(
+        defaultValue=[], typingType=list[JsonSchemaNestedTuple]
+    )
+
+
+@addTupleType
+class JsonSchemaBareListTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonSchemaBareListTuple"
+    items = TupleField(defaultValue=[], typingType=list)
+
+
+@addTupleType
+class JsonSchemaSelfRefTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.JsonSchemaSelfRefTuple"
+    label = TupleField(defaultValue="", typingType=str)
+    parent = TupleField()
+
+
+JsonSchemaSelfRefTuple.parent.typingType = JsonSchemaSelfRefTuple | None

{vortexpy-4.0.29 → vortexpy-4.1.2}/vortexpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.0.29
+Version: 4.1.2
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-4.0.29 → vortexpy-4.1.2}/vortexpy.egg-info/SOURCES.txt

@@ -92,6 +92,12 @@ vortex/sqla_orm/VortexTupleJson.py
 vortex/sqla_orm/__init__.py
 vortex/storage/TupleStorageSqlite.py
 vortex/storage/__init__.py
+vortex/tuple_json_schema/__init__.py
+vortex/tuple_json_schema/constants.py
+vortex/tuple_json_schema/json_schema_node_tuple.py
+vortex/tuple_json_schema/tuple_json_schema_builder.py
+vortex/tuple_json_schema/tuple_json_schema_test.py
+vortex/tuple_json_schema/tuple_json_schema_test_tuples.py
 vortexpy.egg-info/PKG-INFO
 vortexpy.egg-info/SOURCES.txt
 vortexpy.egg-info/dependency_links.txt

vortexpy-4.1.2/vortexpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vortexpy-4.0.29/vortex/__init__.py

@@ -1,9 +0,0 @@
-# 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.0.29'