structurize 3.9.1__tar.gz → 3.9.2__tar.gz

{structurize-3.9.1/structurize.egg-info → structurize-3.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.9.1
+Version: 3.9.2
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3

{structurize-3.9.1 → structurize-3.9.2}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.9.1'
-__version_tuple__ = version_tuple = (3, 9, 1)
+__version__ = version = '3.9.2'
+__version_tuple__ = version_tuple = (3, 9, 2)
 
-__commit_id__ = commit_id = 'gd2cba4eb3'
+__commit_id__ = commit_id = 'g8d1c504ec'

{structurize-3.9.1 → structurize-3.9.2}/avrotize/structuretopython.py

@@ -5,7 +5,8 @@
 import json
 import os
 import re
-import random
+import hashlib
+from random import Random
 from typing import Any, Dict, List, Set, Tuple, Union, Optional
 
 from avrotize.common import pascal, process_template, json_wire_name, json_enum_wire_value
@@ -15,6 +16,432 @@ JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 
 INDENT = '    '
 
+# Python types that need a dataclasses-json encoder/decoder pair.
+# Ordered most-specific first: datetime.datetime is a subclass of datetime.date,
+# so an isinstance chain must test datetime before date.
+JSON_CODEC_SCALARS = (
+    'datetime.datetime',
+    'datetime.date',
+    'datetime.time',
+    'datetime.timedelta',
+    'uuid.UUID',
+    'bytes',
+)
+STRICT_JSON_CODEC_SCALARS = frozenset(
+    ('datetime.timedelta', 'uuid.UUID', 'bytes'))
+
+# Marshmallow field expression per custom JSON scalar. List, set and string-keyed
+# map fields compose these scalar fields so schema() uses the same wire codec.
+#
+# These name generated subclasses rather than marshmallow's own fields, because
+# dataclasses_json.mm.schema() uses a supplied mm_field verbatim: it neither
+# assigns data_key nor applies the field's decoder. A plain fields.Date would
+# therefore lose the JSON field name and parse with marshmallow's own parser,
+# so schema() would disagree with the other four entry points.
+_MM_FIELDS = {
+    'datetime.datetime': '_IsoDateTimeField',
+    'datetime.date': '_IsoDateField',
+    'datetime.time': '_IsoTimeField',
+    'datetime.timedelta': '_DurationField',
+    'uuid.UUID': '_UuidField',
+    'bytes': '_Base64Field',
+}
+
+_JSON_PARSERS = {
+    'datetime.datetime': '_parse_iso_datetime',
+    'datetime.date': '_parse_iso_date',
+    'datetime.time': '_parse_iso_time',
+    'datetime.timedelta': '_parse_duration',
+    'uuid.UUID': '_parse_uuid',
+    'bytes': '_parse_base64',
+}
+
+# Each generated marshmallow field delegates to one of the JSON parsers, so
+# emitting the field also requires emitting its parser.
+_MM_FIELD_PARSERS = {
+    '_IsoDateField': '_parse_iso_date',
+    '_IsoDateTimeField': '_parse_iso_datetime',
+    '_IsoTimeField': '_parse_iso_time',
+    '_DurationField': '_parse_duration',
+    '_UuidField': '_parse_uuid',
+    '_Base64Field': '_parse_base64',
+}
+
+# Emitted in this order so a module's helper block is stable.
+JSON_PARSER_ORDER = (
+    '_parse_iso_date',
+    '_parse_iso_datetime',
+    '_parse_iso_time',
+    '_parse_duration',
+    '_parse_uuid',
+    '_parse_base64',
+)
+MM_FIELD_ORDER = (
+    '_IsoDateField',
+    '_IsoDateTimeField',
+    '_IsoTimeField',
+    '_DurationField',
+    '_UuidField',
+    '_Base64Field',
+    '_SetField',
+)
+
+_GENERIC_RE = re.compile(r'^typing\.(Optional|List|Set|Dict|Union|Tuple|FrozenSet)\[(.+)\]$')
+
+
+def split_type_args(arg_text: str) -> List[str]:
+    """ Splits the comma-separated arguments of a typing generic at bracket depth zero. """
+    args: List[str] = []
+    depth = 0
+    current = ''
+    for char in arg_text:
+        if char == '[':
+            depth += 1
+        elif char == ']':
+            depth -= 1
+        if char == ',' and depth == 0:
+            args.append(current.strip())
+            current = ''
+        else:
+            current += char
+    if current.strip():
+        args.append(current.strip())
+    return args
+
+
+def parse_generic_type(type_name: str) -> Optional[Tuple[str, List[str]]]:
+    """ Splits a typing generic into its origin and its arguments, or None if it is not generic. """
+    match = _GENERIC_RE.match(type_name)
+    if not match:
+        return None
+    origin, arg_text = match.groups()
+    return origin, split_type_args(arg_text)
+
+
+def type_contains_json_codec(type_name: str) -> bool:
+    """ Reports whether a Python type annotation contains a custom JSON scalar at any nesting depth. """
+    if type_name in JSON_CODEC_SCALARS:
+        return True
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return False
+    return any(type_contains_json_codec(arg) for arg in generic[1])
+
+
+NONE_TYPES = ('None', 'NoneType', 'type(None)')
+
+# Branch priorities. Lower is tested first, so datetime must precede date: a
+# datetime.datetime satisfies isinstance(v, datetime.date) as well.
+_PRIORITY_DATETIME = 0
+_PRIORITY_DATE_NARROWING = 1
+_PRIORITY_DATE = 2
+_PRIORITY_TIME = 3
+_PRIORITY_DURATION = 4
+_PRIORITY_UUID = 5
+_PRIORITY_BINARY = 6
+_PRIORITY_CONTAINER = 7
+
+
+def json_codec_scalars_in(type_name: str) -> Set[str]:
+    """ Collects the distinct custom JSON scalars a Python type annotation contains at any depth. """
+    if type_name in JSON_CODEC_SCALARS:
+        return {type_name}
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return set()
+    found: Set[str] = set()
+    for arg in generic[1]:
+        found |= json_codec_scalars_in(arg)
+    return found
+
+
+def union_is_ambiguous(args: List[str]) -> bool:
+    """ Reports whether a union mixes custom scalar arms in a way no undiscriminated codec can encode.
+
+    A union of two custom scalars (``Union[date, datetime]``) cannot be encoded
+    without losing the distinction, and a custom scalar beside an unencoded
+    arm (``Union[date, str]``) cannot be decoded without coercing values that
+    legitimately belong to the other arm. In both cases no codec is emitted, so
+    the pre-existing loud failure is preserved rather than replaced by silent
+    data loss.
+    """
+    arms = [arg for arg in args if arg not in NONE_TYPES]
+    scalars: Set[str] = set()
+    for arm in arms:
+        scalars |= json_codec_scalars_in(arm)
+    if len(scalars) > 1:
+        return True
+    return any(not type_contains_json_codec(arm) for arm in arms)
+
+
+def _codec_branches(type_name: str, var: str, depth: int, encode: bool,
+                    parsers: Set[str]) -> List[Tuple[int, str, str]]:
+    """ Builds the (priority, condition, value) branches of a custom JSON codec expression.
+
+    Every parser referenced by the emitted branches is recorded in ``parsers``
+    so the caller knows exactly which helper definitions the generated module
+    needs. Values whose type the branches do not recognize are left untouched;
+    strings that should use a custom wire format but cannot be parsed raise from
+    the parser.
+    """
+    if type_name == 'datetime.datetime':
+        if encode:
+            return [(_PRIORITY_DATETIME, f'isinstance({var}, datetime.datetime)', f'{var}.isoformat()')]
+        parsers.add('_parse_iso_datetime')
+        return [(_PRIORITY_DATETIME, f'isinstance({var}, str)', f'_parse_iso_datetime({var}, {{field_name}})')]
+    if type_name == 'datetime.date':
+        if encode:
+            # datetime.datetime is a subclass of datetime.date: narrow it to the
+            # date component so the emitted string is parseable by the decoder.
+            # This branch is deliberately ranked below the datetime branch above
+            # so it can never displace it when both appear in one expression.
+            return [(_PRIORITY_DATE_NARROWING, f'isinstance({var}, datetime.datetime)',
+                     f'{var}.date().isoformat()'),
+                    (_PRIORITY_DATE, f'isinstance({var}, datetime.date)', f'{var}.isoformat()')]
+        parsers.add('_parse_iso_date')
+        return [(_PRIORITY_DATE, f'isinstance({var}, str)', f'_parse_iso_date({var}, {{field_name}})')]
+    if type_name == 'datetime.time':
+        if encode:
+            return [(_PRIORITY_TIME, f'isinstance({var}, datetime.time)', f'{var}.isoformat()')]
+        parsers.add('_parse_iso_time')
+        return [(_PRIORITY_TIME, f'isinstance({var}, str)', f'_parse_iso_time({var}, {{field_name}})')]
+    if type_name == 'datetime.timedelta':
+        if encode:
+            return [(_PRIORITY_DURATION, f'isinstance({var}, datetime.timedelta)',
+                     f'_format_duration({var})')]
+        parsers.add('_parse_duration')
+        return [(_PRIORITY_DURATION, 'True',
+                 f'_parse_duration({var}, {{field_name}})')]
+    if type_name == 'uuid.UUID':
+        if encode:
+            return [(_PRIORITY_UUID, f'isinstance({var}, uuid.UUID)', f'str({var})')]
+        parsers.add('_parse_uuid')
+        return [(_PRIORITY_UUID, 'True',
+                 f'_parse_uuid({var}, {{field_name}})')]
+    if type_name == 'bytes':
+        if encode:
+            return [(_PRIORITY_BINARY, f'isinstance({var}, bytes)',
+                     f"base64.b64encode({var}).decode('ascii')")]
+        parsers.add('_parse_base64')
+        return [(_PRIORITY_BINARY, 'True',
+                 f'_parse_base64({var}, {{field_name}})')]
+
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return []
+    origin, args = generic
+
+    if origin in ('Optional', 'Union'):
+        if union_is_ambiguous(args):
+            return []
+        branches: List[Tuple[int, str, str]] = []
+        for arg in args:
+            branches.extend(_codec_branches(arg, var, depth, encode, parsers))
+        branches.sort(key=lambda branch: branch[0])
+        seen: Set[str] = set()
+        unique: List[Tuple[int, str, str]] = []
+        for branch in branches:
+            if branch[1] in seen:
+                continue
+            seen.add(branch[1])
+            unique.append(branch)
+        return unique
+
+    item = f'_item{depth}'
+    # Only homogeneous containers are handled. typing.Tuple is deliberately
+    # excluded because its arguments are positional, so a single element codec
+    # cannot describe it.
+    if origin in ('List', 'Set', 'FrozenSet'):
+        inner = args[0]
+        if not type_contains_json_codec(inner):
+            return []
+        inner_expr = build_codec_expression(inner, item, depth + 1, encode, parsers)
+        comprehension = f'[{inner_expr} for {item} in {var}]'
+        if not encode and origin == 'Set':
+            comprehension = f'set({comprehension})'
+        elif not encode and origin == 'FrozenSet':
+            comprehension = f'frozenset({comprehension})'
+        return [(_PRIORITY_CONTAINER, f'isinstance({var}, (list, tuple, set, frozenset))', comprehension)]
+    if origin == 'Dict':
+        value_type = args[-1]
+        if not type_contains_json_codec(value_type):
+            return []
+        key = f'_key{depth}'
+        inner_expr = build_codec_expression(value_type, item, depth + 1, encode, parsers)
+        return [(_PRIORITY_CONTAINER, f'isinstance({var}, dict)',
+                 f'{{{key}: {inner_expr} for {key}, {item} in {var}.items()}}')]
+    return []
+
+
+def build_codec_expression(type_name: str, var: str, depth: int, encode: bool,
+                           parsers: Set[str]) -> str:
+    """ Builds a custom JSON encode/decode expression over ``var``, or ``var`` itself when nothing applies. """
+    branches = _codec_branches(type_name, var, depth, encode, parsers)
+    expression = var
+    if not encode and (
+            json_codec_scalars_in(type_name) & STRICT_JSON_CODEC_SCALARS):
+        expected_container = decoded_container_kind(type_name)
+        if expected_container:
+            expression = (
+                f"_invalid_container({var}, {{field_name}}, "
+                f"'{expected_container}')"
+            )
+    for _priority, condition, value in reversed(branches):
+        expression = f'{value} if {condition} else {expression}'
+    if not encode and type_allows_none(type_name):
+        expression = f'None if {var} is None else {expression}'
+    return expression
+
+
+def type_allows_none(type_name: str) -> bool:
+    """ Reports whether this exact annotation node declares nullability. """
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return type_name in NONE_TYPES
+    origin, args = generic
+    return origin == 'Optional' or (
+        origin == 'Union' and any(arg in NONE_TYPES for arg in args))
+
+
+def decoded_container_kind(type_name: str) -> Optional[str]:
+    """ Returns the JSON container kind required by a decoded custom-scalar field. """
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return None
+    origin, args = generic
+    if origin == 'Optional':
+        return decoded_container_kind(args[0])
+    if origin in ('List', 'Set', 'FrozenSet'):
+        return 'array'
+    if origin == 'Dict':
+        return 'object'
+    return None
+
+
+def build_mm_field(type_name: str, mm_classes: Set[str],
+                   options: str = '') -> Optional[str]:
+    """ Builds the marshmallow field expression for a custom JSON type, or None when
+    marshmallow has no faithful equivalent (e.g. a union of several custom
+    scalar types).
+
+    ``options`` carries the keyword arguments for the outermost field only, so
+    ``data_key`` is not repeated on the element field of a list or map.
+    """
+    if type_name in _MM_FIELDS:
+        mm_class = _MM_FIELDS[type_name]
+        mm_classes.add(mm_class)
+        return f'{mm_class}({options})'
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return None
+    origin, args = generic
+    if origin == 'Optional':
+        optional_options = options
+        if 'allow_none=' not in optional_options:
+            optional_options += (
+                ', ' if optional_options else '') + 'allow_none=True'
+        return build_mm_field(args[0], mm_classes, optional_options)
+    if origin == 'List':
+        inner = build_mm_field(args[0], mm_classes)
+        return f'fields.List({inner}{", " + options if options else ""})' if inner else None
+    if origin == 'Set':
+        inner = build_mm_field(args[0], mm_classes)
+        if not inner:
+            return None
+        mm_classes.add('_SetField')
+        return f'_SetField({inner}{", " + options if options else ""})'
+    if origin == 'Dict' and len(args) == 2 and args[0] == 'str':
+        inner = build_mm_field(args[1], mm_classes)
+        if not inner:
+            return None
+        return (f'fields.Dict(keys=fields.Str(), values={inner}'
+                f'{", " + options if options else ""})')
+    return None
+
+
+def build_mm_options(type_name: str, json_name: str) -> str:
+    """ Builds the marshmallow keyword arguments that dataclasses_json would have
+    supplied itself.
+
+    ``dataclasses_json.mm.schema()`` only assigns ``data_key``, ``required`` and
+    ``allow_none`` on the branch it takes when no ``mm_field`` is configured, so
+    a field that supplies one has to carry them. ``data_key`` is the same value
+    passed to ``dataclasses_json.config(field_name=...)``, which is what
+    dataclasses_json would have computed from the configured letter case.
+    """
+    # Generated fields are kw_only and carry no default, so dataclasses_json
+    # would mark every one of them required.
+    options = [f'data_key={json_name!r}', 'required=True']
+    generic = parse_generic_type(type_name)
+    if generic and generic[0] == 'Optional':
+        options.append('allow_none=True')
+    return ', '.join(options)
+
+
+def build_container_rebuild(type_name: str) -> Optional[str]:
+    """ Builds an expression rebuilding a declared set container from a JSON list.
+
+    JSON has no set type, so a ``typing.Set`` field arrives as a list. The
+    dataclasses-json ``from_json`` path reconstructs the declared container, and
+    the generated ``from_serializer_dict`` has to do the same or the two paths
+    hand back different container types for the same payload.
+    """
+    generic = parse_generic_type(type_name)
+    if not generic:
+        return None
+    origin, args = generic
+    if origin == 'Optional':
+        inner = build_container_rebuild(args[0])
+        return f'None if v is None else {inner}' if inner else None
+    if origin in ('Set', 'FrozenSet'):
+        return f'{"set" if origin == "Set" else "frozenset"}(v)'
+    return None
+
+
+def build_json_codec(type_name: str, field_name: str) -> Optional[Dict[str, Optional[str]]]:
+    """ Builds the dataclasses-json encoder/decoder/mm_field triple for a custom JSON field type.
+
+    Returns None when the type contains no custom JSON scalar, or when it is a union
+    whose arms cannot be told apart on the wire. The encoder and decoder walk
+    nested ``Optional``/``Union``/``List``/``Set``/``Dict`` annotations, so
+    collections of custom scalars are serialized just like scalar values.
+    """
+    if not type_contains_json_codec(type_name):
+        return None
+    encode_parsers: Set[str] = set()
+    decode_parsers: Set[str] = set()
+    encoder = build_codec_expression(type_name, 'v', 0, True, encode_parsers)
+    decoder = build_codec_expression(type_name, 'v', 0, False, decode_parsers)
+    if encoder == 'v' and decoder == 'v':
+        return None
+
+    # The parsers name the field that rejected a value, so a malformed payload
+    # reports where it came from instead of surfacing a bare isoformat error.
+    decoder = decoder.replace('{field_name}', repr(field_name))
+
+    mm_classes: Set[str] = set()
+    mm_field = build_mm_field(type_name, mm_classes,
+                              build_mm_options(type_name, field_name))
+    if not mm_field:
+        mm_classes.clear()
+
+    # A generated marshmallow field parses with the module's own ISO helper, so
+    # its parser has to be emitted even when no decoder lambda referenced it.
+    parsers = set(decode_parsers)
+    for mm_class in mm_classes:
+        parser = _MM_FIELD_PARSERS.get(mm_class)
+        if parser:
+            parsers.add(parser)
+
+    return {
+        'encoder': f'lambda v: {encoder}',
+        'decoder': f'lambda v: {decoder}',
+        'mm_field': mm_field,
+        'mm_classes': sorted(mm_classes),
+        'parsers': sorted(parsers),
+    }
+
+
 # Python standard library modules that should not be shadowed by package names
 PYTHON_STDLIB_MODULES = {
     'abc', 'aifc', 'argparse', 'array', 'ast', 'asynchat', 'asyncio', 'asyncore',
@@ -407,25 +834,52 @@ class StructureToPython:
         doc = structure_schema.get('description', structure_schema.get('doc', class_name))
 
         # Generate field docstrings
-        field_docstrings = [{
-            'name': self.safe_name(field['name']),
-            'original_name': field.get('json_name') or field['name'],
-            'type': field['type'],
-            'is_primitive': field['is_primitive'],
-            'is_enum': field['is_enum'],
-            'docstring': self.generate_field_docstring(field, schema_namespace),
-            'test_value': self.generate_test_value(field),
-            'source_type': field.get('source_type', 'string'),
-            'xml_name': field['xml_name'],
-            'xml_kind': field['xml_kind'],
-            'xml_namespace': field['xml_namespace'],
-            'xml_metadata': {
-                'type': 'Attribute' if field['xml_kind'] == 'attribute' else 'Element',
-                'name': field['xml_name'],
-                **({'namespace': field['xml_namespace']}
-                   if field['xml_kind'] != 'attribute' and field['xml_namespace'] else {}),
-            },
-        } for field in fields]
+        field_docstrings = []
+        for field in fields:
+            codec = build_json_codec(
+                field['type'], field.get('json_name') or field['name'])
+            field_docstrings.append({
+                'name': self.safe_name(field['name']),
+                'original_name': field.get('json_name') or field['name'],
+                'type': field['type'],
+                'is_primitive': field['is_primitive'],
+                'is_enum': field['is_enum'],
+                'docstring': self.generate_field_docstring(field, schema_namespace),
+                'test_value': self.generate_test_value(field),
+                'source_type': field.get('source_type', 'string'),
+                'json_encoder': codec['encoder'] if codec else None,
+                'json_decoder': codec['decoder'] if codec else None,
+                'mm_field': codec['mm_field'] if codec else None,
+                'mm_classes': codec['mm_classes'] if codec else [],
+                'json_parsers': codec['parsers'] if codec else [],
+                'reject_json_null': (
+                    bool(codec)
+                    and bool(json_codec_scalars_in(field['type'])
+                             & STRICT_JSON_CODEC_SCALARS)
+                    and not type_allows_none(field['type'])
+                ),
+                # A set arrives from JSON as a list. Temporal sets are rebuilt by
+                # their own decoder; every other set needs an explicit rebuild so
+                # from_serializer_dict agrees with the dataclasses-json path.
+                'container_rebuild': (None if self.dataclasses_json_annotation and codec
+                                      else build_container_rebuild(field['type'])),
+                'xml_name': field['xml_name'],
+                'xml_kind': field['xml_kind'],
+                'xml_namespace': field['xml_namespace'],
+                'xml_metadata': {
+                    'type': 'Attribute' if field['xml_kind'] == 'attribute' else 'Element',
+                    'name': field['xml_name'],
+                    **({'namespace': field['xml_namespace']}
+                       if field['xml_kind'] != 'attribute' and field['xml_namespace'] else {}),
+                },
+            })
+
+        # JSON parsing helpers required by the emitted decoders, in a stable order.
+        json_parsers = [parser for parser in JSON_PARSER_ORDER
+                        if any(parser in field['json_parsers'] for field in field_docstrings)]
+        # Marshmallow field subclasses required by the emitted mm_fields.
+        mm_classes = [mm_class for mm_class in MM_FIELD_ORDER
+                      if any(mm_class in field['mm_classes'] for field in field_docstrings)]
 
         # If avro_annotation is enabled, convert JSON Structure schema to Avro schema
         # This is embedded in the generated class for runtime Avro serialization
@@ -443,7 +897,18 @@ class StructureToPython:
             class_name=class_name,
             docstring=doc,
             fields=field_docstrings,
-            import_types=import_types,
+            json_parsers=json_parsers,
+            uses_iso_parser=any(parser.startswith('_parse_iso_') for parser in json_parsers),
+            uses_container_validator=any(
+                field['json_decoder']
+                and '_invalid_container' in field['json_decoder']
+                for field in field_docstrings),
+            needs_base64='_parse_base64' in json_parsers,
+            needs_decimal=('decimal.Decimal' in import_types
+                           or (self.dataclasses_json_annotation
+                               and '_parse_duration' in json_parsers)),
+            mm_classes=mm_classes,
+            import_types=sorted(import_types),
             base_package=self.base_package,
             dataclasses_json_annotation=self.dataclasses_json_annotation,
             avro_annotation=self.avro_annotation,
@@ -765,7 +1230,7 @@ class StructureToPython:
             class_name=class_name,
             docstring=doc,
             values_type=values_type,
-            import_types=import_types,
+            import_types=sorted(import_types),
             base_package=self.base_package
         )
         
@@ -776,8 +1241,17 @@ class StructureToPython:
         return python_qualified_name
 
     def generate_test_value(self, field: Dict) -> Any:
-        """Generates a test value for a given field"""
+        """Generates a test value for a given field.
+
+        The value is drawn from a generator seeded with a stable hash of the field
+        name and type, so repeated generation of the same schema produces
+        byte-identical output regardless of interpreter hash randomization.
+        """
         field_type = field['type']
+        seed = int.from_bytes(
+            hashlib.sha256(f"{field.get('name', '')}:{field_type}".encode('utf-8')).digest()[:8],
+            'big')
+        random = Random(seed)
 
         def generate_value(field_type: str):
             test_values = {
@@ -818,9 +1292,13 @@ class StructureToPython:
                 field_type = resolve(field_type)
 
             if field_type.startswith('typing.List[') or field_type.startswith('typing.Set['):
+                is_set = field_type.startswith('typing.Set[')
                 field_type = resolve(field_type)
                 array_range = random.randint(1, 5)
-                return f"[{', '.join([generate_value(field_type) for _ in range(array_range)])}]"
+                items = f"[{', '.join([generate_value(field_type) for _ in range(array_range)])}]"
+                # A typing.Set field must be constructed as a set, or the value
+                # would not match the container the deserializers rebuild.
+                return f"set({items})" if is_set else items
             elif field_type.startswith('typing.Dict['):
                 field_type = resolve(field_type)
                 dict_range = random.randint(1, 5)
@@ -864,7 +1342,7 @@ class StructureToPython:
             class_name=class_name,
             test_class_name=test_class_name,
             fields=fields,
-            import_types=import_types,
+            import_types=sorted(import_types),
             avro_annotation=self.avro_annotation,
             dataclasses_json_annotation=self.dataclasses_json_annotation
         )

{structurize-3.9.1 → structurize-3.9.2}/avrotize/structuretots.py

@@ -562,32 +562,92 @@ class StructureToTypeScript:
 
     def generate_tuple(self, structure_schema: Dict, parent_namespace: str, 
                       write_file: bool = True, explicit_name: str = '') -> str:
-        """ Generates a TypeScript tuple type from JSON Structure tuple type """
+        """Generates a named TypeScript class that serializes as a JSON array."""
         tuple_name = pascal(explicit_name if explicit_name else structure_schema.get('name', 'Tuple'))
         namespace = self.concat_namespace(self.base_package, structure_schema.get('namespace', parent_namespace)).lower()
         schema_namespace = structure_schema.get('namespace', parent_namespace)
-        typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(parent_namespace, tuple_name)
+        typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(schema_namespace, tuple_name)
         
         if typescript_qualified_name in self.generated_types:
             return typescript_qualified_name
 
         import_types: Set[str] = set()
-        tuple_items = structure_schema.get('items', [])
-        item_types = []
-        for idx, item in enumerate(tuple_items):
+        properties = structure_schema.get('properties', {})
+        tuple_order = structure_schema.get('tuple', [])
+        elements = []
+        for prop_name in tuple_order:
+            prop_schema = properties.get(prop_name, {'type': 'any'})
             item_type = self.convert_structure_type_to_typescript(
-                tuple_name, f'item{idx}', item, schema_namespace, import_types)
-            item_types.append(item_type)
+                tuple_name, prop_name, prop_schema, schema_namespace, import_types)
+            item_type_no_null = self.strip_nullable(item_type)
+            elements.append({
+                'name': self.safe_name(prop_name),
+                'type': item_type_no_null,
+                'test_value': self.generate_test_value({
+                    'type_no_null': item_type_no_null,
+                    'is_enum': any(
+                        import_type.endswith('.' + item_type_no_null)
+                        and self.generated_types.get(import_type) == 'enum'
+                        for import_type in import_types)
+                }),
+                'docstring': prop_schema.get('description', '') if isinstance(prop_schema, dict) else ''
+            })
 
-        # TypeScript tuples are just arrays with fixed length and types
-        tuple_type = f"[{', '.join(item_types)}]"
-        
-        # Generate type alias
-        tuple_definition = f"export type {tuple_name} = {tuple_type};\n"
+        imports = []
+        for import_type in import_types:
+            if import_type == typescript_qualified_name:
+                continue
+            import_type_parts = import_type.split('.')
+            import_type_name = pascal(import_type_parts[-1])
+            import_path = '/'.join(import_type_parts)
+            current_path = '/'.join(namespace.split('.'))
+            relative_import_path = os.path.relpath(import_path, current_path).replace(os.sep, '/')
+            if not relative_import_path.startswith('.'):
+                relative_import_path = f'./{relative_import_path}'
+            imports.append(f"import {{ {import_type_name} }} from '{relative_import_path}.js';")
+
+        tuple_type = f"[{', '.join(element['type'] for element in elements)}]"
+        constructor_parameters = ',\n        '.join(
+            f"public {element['name']}: {element['type']}" for element in elements)
+        array_values = ', '.join(f"this.{element['name']}" for element in elements)
+        parsed_values = ',\n            '.join(
+            f"value[{index}] as {element['type']}" for index, element in enumerate(elements))
+        test_values = ',\n            '.join(element['test_value'] for element in elements)
+        docstring = structure_schema.get('description', f'A {tuple_name} tuple.')
+        tuple_definition = '\n'.join(imports)
+        if imports:
+            tuple_definition += '\n'
+        tuple_definition += f"""/** {docstring} */
+export class {tuple_name} {{
+    constructor(
+        {constructor_parameters}
+    ) {{}}
+
+    public toJSON(): {tuple_type} {{
+        return [{array_values}];
+    }}
+
+    public static fromJSON(json: string): {tuple_name} {{
+        const value: unknown = JSON.parse(json);
+        if (!Array.isArray(value) || value.length !== {len(elements)}) {{
+            throw new Error('Expected a {tuple_name} JSON array with {len(elements)} elements');
+        }}
+        return new {tuple_name}(
+            {parsed_values}
+        );
+    }}
+
+    public static createInstance(): {tuple_name} {{
+        return new {tuple_name}(
+            {test_values}
+        );
+    }}
+}}
+"""
 
         if write_file:
             self.write_to_file(namespace, tuple_name, tuple_definition)
-        self.generated_types[typescript_qualified_name] = 'tuple'
+        self.generated_types[typescript_qualified_name] = 'class'
         return typescript_qualified_name
 
     def generate_test_value(self, field: Dict) -> str:

{structurize-3.9.1 → structurize-3.9.2/structurize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.9.1
+Version: 3.9.2
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3