structurize 3.5.12__tar.gz → 3.6.0__tar.gz

{structurize-3.5.12/structurize.egg-info → structurize-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.12
+Version: 3.6.0
 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.5.12 → structurize-3.6.0}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.5.12'
-__version_tuple__ = version_tuple = (3, 5, 12)
+__version__ = version = '3.6.0'
+__version_tuple__ = version_tuple = (3, 6, 0)
 
-__commit_id__ = commit_id = 'g0eb0a7b9d'
+__commit_id__ = commit_id = 'g1329b8c45'

{structurize-3.5.12 → structurize-3.6.0}/avrotize/avrotokusto.py

@@ -119,15 +119,13 @@ class AvroToKusto:
         # .create-or-alter table dfl_data_events ingestion json mapping
         kusto.append(
             f".create-or-alter table {table_ref} ingestion json mapping \"{mapping_base}_json_flat\"")
-        kusto.append("```\n[")
+        mapping_entries = []
         if emit_cloudevents_columns:
-            kusto.append("  {\"column\": \"___type\", \"path\": \"$.type\"},")
-            kusto.append(
-                "  {\"column\": \"___source\", \"path\": \"$.source\"},")
-            kusto.append("  {\"column\": \"___id\", \"path\": \"$.id\"},")
-            kusto.append("  {\"column\": \"___time\", \"path\": \"$.time\"},")
-            kusto.append(
-                "  {\"column\": \"___subject\", \"path\": \"$.subject\"},")
+            mapping_entries.append("  {\"column\": \"___type\", \"path\": \"$.type\"}")
+            mapping_entries.append("  {\"column\": \"___source\", \"path\": \"$.source\"}")
+            mapping_entries.append("  {\"column\": \"___id\", \"path\": \"$.id\"}")
+            mapping_entries.append("  {\"column\": \"___time\", \"path\": \"$.time\"}")
+            mapping_entries.append("  {\"column\": \"___subject\", \"path\": \"$.subject\"}")
         for field in fields:
             json_name = column_name = field["name"]
             if 'altnames' in field:
@@ -135,21 +133,19 @@ class AvroToKusto:
                     column_name = field['altnames']['kql']
                 if 'json' in field['altnames']:
                     json_name = field['altnames']['json']
-            kusto.append(
-                f"  {{\"column\": \"{column_name}\", \"path\": \"$.{json_name}\"}},")
-        kusto.append("]\n```\n\n")
+            mapping_entries.append(
+                f"  {{\"column\": \"{column_name}\", \"path\": \"$.{json_name}\"}}")
+        kusto.append("```\n[\n" + ",\n".join(mapping_entries) + "\n]\n```\n\n")
 
         if emit_cloudevents_columns:
             kusto.append(
                 f".create-or-alter table {table_ref} ingestion json mapping \"{mapping_base}_json_ce_structured\"")
-            kusto.append("```\n[")
-            kusto.append("  {\"column\": \"___type\", \"path\": \"$.type\"},")
-            kusto.append(
-                "  {\"column\": \"___source\", \"path\": \"$.source\"},")
-            kusto.append("  {\"column\": \"___id\", \"path\": \"$.id\"},")
-            kusto.append("  {\"column\": \"___time\", \"path\": \"$.time\"},")
-            kusto.append(
-                "  {\"column\": \"___subject\", \"path\": \"$.subject\"},")
+            ce_entries = []
+            ce_entries.append("  {\"column\": \"___type\", \"path\": \"$.type\"}")
+            ce_entries.append("  {\"column\": \"___source\", \"path\": \"$.source\"}")
+            ce_entries.append("  {\"column\": \"___id\", \"path\": \"$.id\"}")
+            ce_entries.append("  {\"column\": \"___time\", \"path\": \"$.time\"}")
+            ce_entries.append("  {\"column\": \"___subject\", \"path\": \"$.subject\"}")
             for field in fields:
                 json_name = column_name = field["name"]
                 if 'altnames' in field:
@@ -157,9 +153,9 @@ class AvroToKusto:
                         column_name = field['altnames']['kql']
                     if 'json' in field['altnames']:
                         json_name = field['altnames']['json']
-                kusto.append(
-                    f"  {{\"column\": \"{column_name}\", \"path\": \"$.data.{json_name}\"}},")
-            kusto.append("]\n```\n\n")
+                ce_entries.append(
+                    f"  {{\"column\": \"{column_name}\", \"path\": \"$.data.{json_name}\"}}")
+            kusto.append("```\n[\n" + ",\n".join(ce_entries) + "\n]\n```\n\n")
 
         if emit_cloudevents_columns:
             kusto.append(
@@ -196,7 +192,7 @@ class AvroToKusto:
             kusto.append(
                 f"  \"Query\": \"{query}\",")
             kusto.append("  \"IsTransactional\": false,")
-            kusto.append("  \"PropagateIngestionProperties\": true,")
+            kusto.append("  \"PropagateIngestionProperties\": true")
             kusto.append("}]")
             kusto.append("```\n")
 

{structurize-3.5.12 → structurize-3.6.0}/avrotize/common.py

@@ -830,6 +830,52 @@ def altname(schema_obj: dict, purpose: str):
     return schema_obj["name"]
 
 
+def json_wire_name(prop_name: str, prop_schema: Any) -> str:
+    """
+    Resolve the JSON wire key for a property, honoring JSON Structure ``altnames.json``.
+
+    JSON Structure requires property keys to be identifiers. A non-identifier wire key
+    (e.g. ``dr-type``) is modeled as an identifier property name (``dr_type``) carrying
+    ``altnames: {"json": "dr-type"}``. The ``json`` purpose is the canonical wire name.
+
+    Args:
+        prop_name (str): The property name (identifier) used as the schema key.
+        prop_schema (Any): The property schema; may carry an ``altnames`` map.
+
+    Returns:
+        str: ``altnames.json`` when present, otherwise ``prop_name``.
+    """
+    if isinstance(prop_schema, dict):
+        altnames = prop_schema.get("altnames")
+        if isinstance(altnames, dict) and "json" in altnames:
+            return altnames["json"]
+    return prop_name
+
+
+def json_enum_wire_value(value: Any, enum_schema: Any) -> str:
+    """
+    Resolve the JSON wire string for an enum value, honoring JSON Structure ``altenums.json``.
+
+    ``altenums.json`` is a map keyed by the original enum value; the language member name
+    stays derived from the original value, while the wire value uses the mapping when present.
+    Unmapped values serialize verbatim (identity fallback).
+
+    Args:
+        value: The original enum value (schema key).
+        enum_schema (Any): The enum schema; may carry an ``altenums`` map.
+
+    Returns:
+        str: ``altenums.json[value]`` when present, otherwise ``str(value)``.
+    """
+    if isinstance(enum_schema, dict):
+        altenums = enum_schema.get("altenums")
+        if isinstance(altenums, dict):
+            j = altenums.get("json")
+            if isinstance(j, dict) and str(value) in j:
+                return j[str(value)]
+    return str(value)
+
+
 def process_template(file_path: str, **kvargs) -> str:
     """
     Process a file as a Jinja2 template with the given object as input.

{structurize-3.5.12 → structurize-3.6.0}/avrotize/dependencies/typescript/node22/package.json

@@ -8,7 +8,7 @@
     "kafkajs": "^2.2.4"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
+    "@types/node": "^26.0.0",
     "typescript": "^6.0.2",
     "jest": "^30.2.0",
     "@types/jest": "^30.0.0"

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretocpp.py

@@ -5,7 +5,7 @@ import json
 import os
 from typing import Dict, List, Union, Set, Optional, Any, cast
 
-from avrotize.common import pascal, process_template
+from avrotize.common import pascal, process_template, json_wire_name, json_enum_wire_value
 
 INDENT = '    '
 
@@ -307,9 +307,10 @@ class StructureToCpp:
                     source_type = 'object'
             else:
                 source_type = 'object'
-            all_field_info.append((field_name, prop_name, field_type, source_type))
+            wire_name = json_wire_name(prop_name, prop_schema)
+            all_field_info.append((field_name, wire_name, field_type, source_type))
             if source_type in ('int64', 'uint64', 'int128', 'uint128', 'decimal'):
-                string_json_fields.append((field_name, prop_name, field_type, source_type))
+                string_json_fields.append((field_name, wire_name, field_type, source_type))
             
             # Add documentation
             if 'description' in prop_schema or 'doc' in prop_schema:
@@ -330,8 +331,10 @@ class StructureToCpp:
         if self.json_annotation:
             class_definition += self.generate_to_json_method(class_name)
         
-        # Add custom nlohmann to_json/from_json if we have string-serialized numeric fields
-        if self.json_annotation and string_json_fields:
+        # Add custom nlohmann to_json/from_json if we have string-serialized numeric
+        # fields or any field whose JSON wire key differs from the C++ member name
+        has_renamed_fields = any(o != f for f, o, _, _ in all_field_info)
+        if self.json_annotation and (string_json_fields or has_renamed_fields):
             class_definition += f"\n{INDENT}friend void to_json(nlohmann::json& j, const {class_name}& v) {{\n"
             class_definition += f"{INDENT}{INDENT}j = nlohmann::json::object();\n"
             for fname, orig_name, ftype, stype in all_field_info:
@@ -394,10 +397,14 @@ class StructureToCpp:
             enum_definition += f"// {doc}\n"
         
         symbols = structure_schema.get('enum', [])
+        members = [(self.safe_identifier(str(s)), json_enum_wire_value(s, structure_schema)) for s in symbols]
         enum_definition += f"enum class {enum_name} {{\n"
-        for symbol in symbols:
-            enum_definition += f"{INDENT}{self.safe_identifier(str(symbol))},\n"
+        for name, _ in members:
+            enum_definition += f"{INDENT}{name},\n"
         enum_definition += "};\n\n"
+        if members:
+            pairs = ", ".join(f'{{{enum_name}::{name}, "{wire}"}}' for name, wire in members)
+            enum_definition += f"NLOHMANN_JSON_SERIALIZE_ENUM({enum_name}, {{ {pairs} }})\n\n"
         
         if write_file:
             self.write_to_file(namespace, enum_name, "", enum_definition)

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretocsharp.py

@@ -8,7 +8,7 @@ import re
 from typing import Any, Dict, List, Tuple, Union, cast, Optional
 import uuid
 
-from avrotize.common import pascal, process_template
+from avrotize.common import pascal, process_template, json_wire_name, json_enum_wire_value
 from avrotize.jstructtoavro import JsonStructureToAvro
 from avrotize.constants import (
     NEWTONSOFT_JSON_VERSION,
@@ -479,8 +479,9 @@ class StructureToCSharp:
         else:
             field_name_cs = field_name
         
-        # Track if field name differs from original for JSON annotation
-        needs_json_annotation = field_name_cs != prop_name
+        # JSON wire key honors JSON Structure altnames.json; annotate when it differs
+        wire_name = json_wire_name(prop_name, prop_schema)
+        needs_json_annotation = field_name_cs != wire_name
         
         # Check if this is a const field
         if 'const' in prop_schema:
@@ -498,9 +499,9 @@ class StructureToCSharp:
             # Add JSON property name annotation when property name differs from schema name
             # This is needed for proper JSON serialization/deserialization, especially with pascal_properties
             if needs_json_annotation:
-                property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{prop_name}")]\n'
+                property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{wire_name}")]\n'
             if self.newtonsoft_json_annotation and needs_json_annotation:
-                property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{prop_name}")]\n'
+                property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{wire_name}")]\n'
             
             # Add XML element annotation if enabled
             if self.system_xml_annotation:
@@ -533,9 +534,9 @@ class StructureToCSharp:
         # Add JSON property name annotation when property name differs from schema name
         # This is needed for proper JSON serialization/deserialization, especially with pascal_properties
         elif needs_json_annotation:
-            property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{prop_name}")]\n'
+            property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{wire_name}")]\n'
         if self.newtonsoft_json_annotation and needs_json_annotation:
-            property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{prop_name}")]\n'
+            property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{wire_name}")]\n'
         
         # Add XML element annotation if enabled
         if self.system_xml_annotation:
@@ -765,7 +766,7 @@ class StructureToCSharp:
             enum_definition += f"{INDENT*2}{{\n"
             for value in enum_values:
                 member_name = pascal(str(value).replace('-', '_').replace(' ', '_'))
-                enum_definition += f'{INDENT*3}"{value}" => {enum_name}.{member_name},\n'
+                enum_definition += f'{INDENT*3}"{json_enum_wire_value(value, structure_schema)}" => {enum_name}.{member_name},\n'
             enum_definition += f'{INDENT*3}_ => throw new System.Text.Json.JsonException($"Unknown value \'{{stringValue}}\' for {enum_name}")\n'
             enum_definition += f"{INDENT*2}}};\n"
         
@@ -783,7 +784,7 @@ class StructureToCSharp:
             enum_definition += f"{INDENT*2}{{\n"
             for value in enum_values:
                 member_name = pascal(str(value).replace('-', '_').replace(' ', '_'))
-                enum_definition += f'{INDENT*3}{enum_name}.{member_name} => "{value}",\n'
+                enum_definition += f'{INDENT*3}{enum_name}.{member_name} => "{json_enum_wire_value(value, structure_schema)}",\n'
             enum_definition += f'{INDENT*3}_ => throw new System.ArgumentOutOfRangeException(nameof(value))\n'
             enum_definition += f"{INDENT*2}}};\n"
             enum_definition += f"{INDENT*2}writer.WriteStringValue(stringValue);\n"
@@ -813,7 +814,7 @@ class StructureToCSharp:
                 enum_definition += f"{INDENT*2}{{\n"
                 for value in enum_values:
                     member_name = pascal(str(value).replace('-', '_').replace(' ', '_'))
-                    enum_definition += f'{INDENT*3}"{value}" => {enum_name}.{member_name},\n'
+                    enum_definition += f'{INDENT*3}"{json_enum_wire_value(value, structure_schema)}" => {enum_name}.{member_name},\n'
                 enum_definition += f'{INDENT*3}_ => throw new Newtonsoft.Json.JsonException($"Unknown value \'{{stringValue}}\' for {enum_name}")\n'
                 enum_definition += f"{INDENT*2}}};\n"
             
@@ -831,7 +832,7 @@ class StructureToCSharp:
                 enum_definition += f"{INDENT*2}{{\n"
                 for value in enum_values:
                     member_name = pascal(str(value).replace('-', '_').replace(' ', '_'))
-                    enum_definition += f'{INDENT*3}{enum_name}.{member_name} => "{value}",\n'
+                    enum_definition += f'{INDENT*3}{enum_name}.{member_name} => "{json_enum_wire_value(value, structure_schema)}",\n'
                 enum_definition += f'{INDENT*3}_ => throw new System.ArgumentOutOfRangeException(nameof(value))\n'
                 enum_definition += f"{INDENT*2}}};\n"
                 enum_definition += f"{INDENT*2}writer.WriteValue(stringValue);\n"
@@ -2444,3 +2445,4 @@ def convert_structure_schema_to_csharp(
     structtocs.system_xml_annotation = system_xml_annotation
     structtocs.avro_annotation = avro_annotation
     structtocs.convert_schema(structure_schema, output_dir)
+

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretogo.py

@@ -6,7 +6,7 @@ import json
 import os
 from typing import Any, Dict, List, Set, Union, Optional, cast
 
-from avrotize.common import pascal, render_template
+from avrotize.common import pascal, render_template, json_wire_name, json_enum_wire_value
 
 JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 
@@ -341,7 +341,7 @@ class StructureToGo:
             fields.append({
                 'name': pascal(prop_name),
                 'type': field_type,
-                'original_name': prop_name,
+                'original_name': json_wire_name(prop_name, prop_schema),
                 'source_type': source_type
             })
 
@@ -401,7 +401,8 @@ class StructureToGo:
         self.generated_types[go_enum_name] = "enum"
         self.generated_structure_types[go_enum_name] = structure_schema
 
-        symbols = structure_schema.get('enum', [])
+        raw_symbols = structure_schema.get('enum', [])
+        symbols = [{'name': str(s), 'value': json_enum_wire_value(s, structure_schema)} for s in raw_symbols]
         
         # Determine base type
         base_type = structure_schema.get('type', 'string')
@@ -423,10 +424,10 @@ class StructureToGo:
 
         self.enums.append({
             'name': go_enum_name,
-            'symbols': symbols,
+            'symbols': [s['name'] for s in symbols],
         })
 
-        self.generate_unit_test('enum', go_enum_name, symbols)
+        self.generate_unit_test('enum', go_enum_name, [s['name'] for s in symbols])
 
         return go_enum_name
 

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretojava.py

@@ -6,7 +6,7 @@ import os
 from typing import Dict, List, Tuple, Union, Set, Optional, Any
 from avrotize.constants import JACKSON_VERSION, JACKSON_ANNOTATIONS_VERSION
 
-from avrotize.common import pascal, camel, process_template
+from avrotize.common import pascal, camel, process_template, json_wire_name, json_enum_wire_value
 
 INDENT = '    '
 
@@ -446,7 +446,7 @@ class StructureToJava:
             source_type = 'object'
         return {
             'name': safe_field_name,
-            'original_name': prop_name,
+            'original_name': json_wire_name(prop_name, prop_schema),
             'type': field_type.type_name,
             'source_type': source_type,
             'docstring': doc,
@@ -611,15 +611,16 @@ class StructureToJava:
                 symbols=symbol_list
             )
         else:
-            # String enum
-            safe_symbols = [self.safe_identifier(pascal(str(symbol).replace('-', '_').replace(' ', '_'))) for symbol in symbols]
+            # String enum — member name from original value; JSON wire value via altenums.json
+            symbol_list = [{'name': self.safe_identifier(pascal(str(symbol).replace('-', '_').replace(' ', '_'))),
+                            'value': json_enum_wire_value(symbol, structure_schema)} for symbol in symbols]
             enum_definition = process_template(
                 "structuretojava/enum_core.jinja",
                 class_name=enum_name,
                 docstring=doc,
                 deprecated=deprecated,
                 is_numeric=False,
-                symbols=safe_symbols
+                symbols=symbol_list
             )
         
         if write_file:

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretokusto.py

@@ -352,43 +352,39 @@ class StructureToKusto:
         # add the JSON mapping for the table
         kusto.append(
             f".create-or-alter table {table_ref} ingestion json mapping \"{mapping_base}_json_flat\"")
-        kusto.append("```\n[")
+        mapping_entries = []
         if emit_cloudevents_columns:
-            kusto.append("  {\"column\": \"___type\", \"path\": \"$.type\"},")
-            kusto.append(
-                "  {\"column\": \"___source\", \"path\": \"$.source\"},")
-            kusto.append("  {\"column\": \"___id\", \"path\": \"$.id\"},")
-            kusto.append("  {\"column\": \"___time\", \"path\": \"$.time\"},")
-            kusto.append(
-                "  {\"column\": \"___subject\", \"path\": \"$.subject\"},")
+            mapping_entries.append("  {\"column\": \"___type\", \"path\": \"$.type\"}")
+            mapping_entries.append("  {\"column\": \"___source\", \"path\": \"$.source\"}")
+            mapping_entries.append("  {\"column\": \"___id\", \"path\": \"$.id\"}")
+            mapping_entries.append("  {\"column\": \"___time\", \"path\": \"$.time\"}")
+            mapping_entries.append("  {\"column\": \"___subject\", \"path\": \"$.subject\"}")
         for prop_name, prop_schema in properties.items():
             # Skip const fields in JSON mapping since they're not stored as columns
             if isinstance(prop_schema, dict) and 'const' in prop_schema:
                 continue
             column_name = prop_name
-            kusto.append(
-                f"  {{\"column\": \"{column_name}\", \"path\": \"$.{prop_name}\"}},")
-        kusto.append("]\n```\n\n")
+            mapping_entries.append(
+                f"  {{\"column\": \"{column_name}\", \"path\": \"$.{prop_name}\"}}")
+        kusto.append("```\n[\n" + ",\n".join(mapping_entries) + "\n]\n```\n\n")
 
         if emit_cloudevents_columns:
             kusto.append(
                 f".create-or-alter table {table_ref} ingestion json mapping \"{mapping_base}_json_ce_structured\"")
-            kusto.append("```\n[")
-            kusto.append("  {\"column\": \"___type\", \"path\": \"$.type\"},")
-            kusto.append(
-                "  {\"column\": \"___source\", \"path\": \"$.source\"},")
-            kusto.append("  {\"column\": \"___id\", \"path\": \"$.id\"},")
-            kusto.append("  {\"column\": \"___time\", \"path\": \"$.time\"},")
-            kusto.append(
-                "  {\"column\": \"___subject\", \"path\": \"$.subject\"},")
+            ce_entries = []
+            ce_entries.append("  {\"column\": \"___type\", \"path\": \"$.type\"}")
+            ce_entries.append("  {\"column\": \"___source\", \"path\": \"$.source\"}")
+            ce_entries.append("  {\"column\": \"___id\", \"path\": \"$.id\"}")
+            ce_entries.append("  {\"column\": \"___time\", \"path\": \"$.time\"}")
+            ce_entries.append("  {\"column\": \"___subject\", \"path\": \"$.subject\"}")
             for prop_name, prop_schema in properties.items():
                 # Skip const fields in JSON mapping since they're not stored as columns
                 if isinstance(prop_schema, dict) and 'const' in prop_schema:
                     continue
                 column_name = prop_name
-                kusto.append(
-                    f"  {{\"column\": \"{column_name}\", \"path\": \"$.data.{prop_name}\"}},")
-            kusto.append("]\n```\n\n")
+                ce_entries.append(
+                    f"  {{\"column\": \"{column_name}\", \"path\": \"$.data.{prop_name}\"}}")
+            kusto.append("```\n[\n" + ",\n".join(ce_entries) + "\n]\n```\n\n")
 
         if emit_cloudevents_columns:
             kusto.append(
@@ -421,7 +417,7 @@ class StructureToKusto:
             kusto.append(
                 f"  \"Query\": \"{query}\",")
             kusto.append("  \"IsTransactional\": false,")
-            kusto.append("  \"PropagateIngestionProperties\": true,")
+            kusto.append("  \"PropagateIngestionProperties\": true")
             kusto.append("}]")
             kusto.append("```\n")
 

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretopython.py

@@ -8,7 +8,7 @@ import re
 import random
 from typing import Any, Dict, List, Set, Tuple, Union, Optional
 
-from avrotize.common import pascal, process_template
+from avrotize.common import pascal, process_template, json_wire_name, json_enum_wire_value
 from avrotize.jstructtoavro import JsonStructureToAvro
 
 JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
@@ -437,8 +437,9 @@ class StructureToPython:
         """ Generates a field for a Python dataclass """
         # Sanitize field name for Python identifier validity
         field_name = self.safe_identifier(prop_name, class_name)
-        # Track if we need a field_name annotation for JSON serialization
-        needs_field_name_annotation = field_name != prop_name
+        # Wire key honors JSON Structure altnames.json; annotation needed when it differs
+        wire_name = json_wire_name(prop_name, prop_schema)
+        needs_field_name_annotation = wire_name != field_name
 
         # Check if this is a const field
         if 'const' in prop_schema:
@@ -447,7 +448,7 @@ class StructureToPython:
                 class_name, field_name, prop_schema, parent_namespace, import_types)
             return {
                 'name': field_name,
-                'json_name': prop_name if needs_field_name_annotation else None,
+                'json_name': wire_name if needs_field_name_annotation else None,
                 'type': prop_type,
                 'is_primitive': self.is_python_primitive(prop_type) or self.is_python_typing_struct(prop_type),
                 'is_enum': False,
@@ -482,7 +483,7 @@ class StructureToPython:
 
         return {
             'name': field_name,
-            'json_name': prop_name if needs_field_name_annotation else None,
+            'json_name': wire_name if needs_field_name_annotation else None,
             'type': prop_type,
             'is_primitive': self.is_python_primitive(prop_type) or self.is_python_typing_struct(prop_type),
             'is_enum': prop_type in self.generated_types and self.generated_types[prop_type] == 'enum',
@@ -612,7 +613,7 @@ class StructureToPython:
             if is_numeric:
                 value_repr = repr(value)
             else:
-                value_repr = repr(str(value))
+                value_repr = repr(json_enum_wire_value(value, structure_schema))
             members.append((member_name, value_repr))
             symbols.append(member_name)
 

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretorust.py

@@ -7,7 +7,7 @@ import os
 import re
 from typing import Any, Dict, List, Set, Tuple, Union, Optional
 
-from avrotize.common import pascal, snake, render_template
+from avrotize.common import pascal, snake, render_template, json_wire_name, json_enum_wire_value
 
 JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 
@@ -307,7 +307,7 @@ class StructureToRust:
             if 'const' in prop_schema:
                 continue
             
-            original_field_name = prop_name
+            original_field_name = json_wire_name(prop_name, prop_schema)
             field_name = self.safe_identifier(snake(prop_name))
             
             # Determine if required
@@ -382,12 +382,11 @@ class StructureToRust:
         # Convert enum values to valid Rust identifiers
         symbols = []
         for value in enum_values:
+            wire = json_enum_wire_value(value, structure_schema)
             if isinstance(value, str):
-                # Convert to PascalCase and make it a valid Rust identifier
                 symbol = pascal(value.replace('-', '_').replace(' ', '_'))
-                symbols.append({'name': symbol, 'value': value})
+                symbols.append({'name': symbol, 'value': wire})
             else:
-                # For numeric values, use Value prefix
                 symbols.append({'name': f"Value{value}", 'value': str(value)})
 
         doc = structure_schema.get('description', structure_schema.get('doc', enum_name))

{structurize-3.5.12 → structurize-3.6.0}/avrotize/structuretots.py

@@ -8,7 +8,7 @@ import random
 import re
 from typing import Any, Dict, List, Set, Tuple, Union, Optional
 
-from avrotize.common import pascal, process_template
+from avrotize.common import pascal, process_template, json_wire_name, json_enum_wire_value
 
 JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 
@@ -356,7 +356,7 @@ class StructureToTypeScript:
                 source_type = 'object'
             fields.append({
                 'name': self.safe_name(prop_name),
-                'original_name': prop_name,
+                'original_name': json_wire_name(prop_name, prop_schema),
                 'type': field_type,
                 'type_no_null': field_type_no_null,
                 'source_type': source_type,
@@ -421,7 +421,8 @@ class StructureToTypeScript:
         if typescript_qualified_name in self.generated_types:
             return typescript_qualified_name
 
-        symbols = structure_schema.get('enum', [])
+        raw_symbols = structure_schema.get('enum', [])
+        symbols = [{'name': str(s), 'value': json_enum_wire_value(s, structure_schema)} for s in raw_symbols]
         
         enum_definition = process_template(
             "structuretots/enum_core.ts.jinja",

{structurize-3.5.12 → structurize-3.6.0/structurize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.12
+Version: 3.6.0
 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