structurize 3.5.8__tar.gz → 3.5.9__tar.gz

{structurize-3.5.8/structurize.egg-info → structurize-3.5.9}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.5.8'
-__version_tuple__ = version_tuple = (3, 5, 8)
+__version__ = version = '3.5.9'
+__version_tuple__ = version_tuple = (3, 5, 9)
 
-__commit_id__ = commit_id = 'g3100f0e10'
+__commit_id__ = commit_id = 'gb097b347e'

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotocpp.py

@@ -5,7 +5,7 @@ import json
 import os
 from typing import Dict, List, Union
 
-from avrotize.common import is_generic_avro_type, pascal, process_template
+from avrotize.common import is_generic_avro_type, is_any_value_type, pascal, process_template
 
 INDENT = '    '
 
@@ -45,6 +45,9 @@ class AvroToCpp:
 
     def map_primitive_to_cpp(self, avro_type: str, is_optional: bool) -> str:
         """Maps Avro primitive types to C++ types"""
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if is_any_value_type(avro_type):
+            return 'std::optional<nlohmann::json>' if is_optional else 'nlohmann::json'
         optional_mapping = {
             'null': 'std::optional<std::monostate>',
             'boolean': 'std::optional<bool>',
@@ -53,7 +56,7 @@ class AvroToCpp:
             'float': 'std::optional<float>',
             'double': 'std::optional<double>',
             'bytes': 'std::optional<std::vector<uint8_t>>',
-            'string': 'std::optional<std::string>'
+            'string': 'std::optional<std::string>',
         }
         required_mapping = {
             'null': 'std::monostate',
@@ -63,7 +66,7 @@ class AvroToCpp:
             'float': 'float',
             'double': 'double',
             'bytes': 'std::vector<uint8_t>',
-            'string': 'std::string'
+            'string': 'std::string',
         }
         if '.' in avro_type:
             type_name = avro_type.split('.')[-1]

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotogo.py

@@ -1,7 +1,7 @@
 import json
 import os
 from typing import Dict, List, Union, Set
-from avrotize.common import get_longest_namespace_prefix, is_generic_avro_type, pascal, render_template
+from avrotize.common import get_longest_namespace_prefix, is_generic_avro_type, is_any_value_type, pascal, render_template
 
 INDENT = '    '
 
@@ -55,6 +55,9 @@ class AvroToGo:
 
     def map_primitive_to_go(self, avro_type: str, is_optional: bool) -> str:
         """Maps Avro primitive types to Go types"""
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if is_any_value_type(avro_type):
+            return 'interface{}'
         optional_mapping = {
             'null': 'interface{}',
             'boolean': '*bool',

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotojava.py

@@ -7,7 +7,7 @@ from typing import Dict, List, Tuple, Union
 from avrotize.constants import (AVRO_VERSION, JACKSON_ANNOTATIONS_VERSION, JACKSON_VERSION,
                                 JDK_VERSION, JUNIT_VERSION, MAVEN_COMPILER_VERSION, MAVEN_SUREFIRE_VERSION)
 
-from avrotize.common import pascal, camel, is_generic_avro_type, inline_avro_references, build_flat_type_dict
+from avrotize.common import pascal, camel, is_generic_avro_type, is_any_value_type, inline_avro_references, build_flat_type_dict
 
 INDENT = '    '
 POM_CONTENT = """<?xml version="1.0" encoding="UTF-8"?>
@@ -296,6 +296,9 @@ class AvroToJava:
     
     def map_primitive_to_java(self, avro_type: str, is_optional: bool) -> JavaType:
         """Maps Avro primitive types to Java types"""
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if is_any_value_type(avro_type):
+            return AvroToJava.JavaType('Object')
         optional_mapping = {
             'null': 'Void',
             'boolean': 'Boolean',
@@ -1314,9 +1317,10 @@ class AvroToJava:
             
             union_variable_name = self.safe_identifier(union_variable_name, class_name)
 
-            # Constructor for each type
-            class_definition_ctors += \
-                f"{INDENT*1}public {union_class_name}({union_type.type_name} {union_variable_name}) {{\n{INDENT*2}this._{camel(union_variable_name)} = {union_variable_name};\n{INDENT*1}}}\n"
+            # Constructor for each type (skip Object to avoid duplicate with the generic Object constructor)
+            if union_type.type_name != 'Object':
+                class_definition_ctors += \
+                    f"{INDENT*1}public {union_class_name}({union_type.type_name} {union_variable_name}) {{\n{INDENT*2}this._{camel(union_variable_name)} = {union_variable_name};\n{INDENT*1}}}\n"
 
             # Declarations
             class_definition_decls += \

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotojs.py

@@ -5,6 +5,7 @@ import os
 from typing import Any, Dict, List, Set, Union
 
 from avrotize.common import pascal
+from avrotize.common import is_any_value_type
 
 INDENT = ' ' * 4
 
@@ -34,6 +35,9 @@ class AvroToJavaScript:
 
     def map_primitive_to_javascript(self, avro_type: str) -> str:
         """ Map Avro primitive type to TypeScript type """
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if is_any_value_type(avro_type):
+            return 'any'
         mapping = {
             'null': 'null',
             'boolean': 'boolean',

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotojsons.py

@@ -1,7 +1,7 @@
 import copy
 import json
 from typing import Dict, Any, Union, List
-from avrotize.common import build_tree_hash_list, group_by_hash, is_generic_json_type, NodeHashReference
+from avrotize.common import build_tree_hash_list, group_by_hash, is_any_value_type, is_generic_json_type, NodeHashReference
 from functools import reduce
 import jsonpath_ng 
 
@@ -141,8 +141,11 @@ class AvroToJsonSchemaConverter:
             'double': {'type': 'number', 'format': 'double'},
             'bytes': {'type': 'string', 'contentEncoding': 'base64'},
             'string': {'type': 'string'},
-            'fixed': {'type': 'string'}  # Could specify length in a format or a separate attribute
+            'fixed': {'type': 'string'},  # Could specify length in a format or a separate attribute
         }
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if isinstance(avro_type, str) and is_any_value_type(avro_type):
+            return {}
         type_ref = mapping.get(avro_type, '')  # Defaulting to string type for any unknown types
         if not type_ref:
             raise ValueError(f"Avro schema contains unexpected type {avro_type}")

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotojstruct.py

@@ -2,6 +2,8 @@ import json
 import uuid
 from typing import Any, Dict, List, Union
 
+from avrotize.common import is_any_value_type
+
 
 class AvroToJsonStructure:
     """
@@ -220,6 +222,8 @@ class AvroToJsonStructure:
 
         # ------------------ STRING (primitive or reference) --------------
         if isinstance(avro_type_schema, str):
+            if is_any_value_type(avro_type_schema):
+                return {"type": "any"}
             if avro_type_schema in self.get_primitive_types():
                 return {"type": self.get_primitive_types()[avro_type_schema]}
             # Named type reference

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotoproto.py

@@ -4,6 +4,8 @@ import argparse
 import os
 from typing import Literal, NamedTuple, Dict, Any, List
 
+from avrotize.common import is_any_value_type
+
 indent = '  '
 
 Comment = NamedTuple('Comment', [('content', str), ('tags', Dict[str, Any])])
@@ -39,6 +41,10 @@ class AvroToProto:
             'bytes': 'bytes',
             'string': 'string',
         }
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if isinstance(avro_type, str) and is_any_value_type(avro_type):
+            dependencies.append('google/protobuf/any.proto')
+            return 'google.protobuf.Any'
         # logical types require special handling
         if isinstance(avro_type, dict) and 'logicalType' in avro_type:
             logical_type = avro_type['logicalType']

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotopython.py

@@ -8,7 +8,7 @@ import os
 import re
 import random
 from typing import Dict, List, Set, Tuple, Union, Any
-from avrotize.common import fullname, get_typing_args_from_string, is_generic_avro_type, pascal, process_template, build_flat_type_dict, inline_avro_references, is_type_with_alternate, strip_alternate_type
+from avrotize.common import fullname, get_typing_args_from_string, is_generic_avro_type, is_any_value_type, pascal, process_template, build_flat_type_dict, inline_avro_references, is_type_with_alternate, strip_alternate_type
 
 INDENT = '    '
 
@@ -145,6 +145,9 @@ class AvroToPython:
         }
         if is_generic_avro_type(avro_type):
             return True, 'typing.Any'
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if isinstance(avro_type, str) and is_any_value_type(avro_type):
+            return True, 'typing.Any'
         mapped = mapping.get(avro_type, None)
         if mapped:
             return True, mapped

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotorust.py

@@ -1,7 +1,7 @@
 import json
 import os
 from typing import Dict, List, Union
-from avrotize.common import is_generic_avro_type, render_template, pascal, camel, snake
+from avrotize.common import is_generic_avro_type, is_any_value_type, render_template, pascal, camel, snake
 
 INDENT = '    '
 
@@ -44,6 +44,9 @@ class AvroToRust:
 
     def map_primitive_to_rust(self, avro_fullname: str, is_optional: bool) -> str:
         """Maps Avro primitive types to Rust types"""
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if is_any_value_type(avro_fullname):
+            return 'Option<serde_json::Value>' if is_optional else 'serde_json::Value'
         optional_mapping = {
             'null': 'None',
             'boolean': 'Option<bool>',
@@ -279,15 +282,25 @@ class AvroToRust:
         
         # Track seen predicates to identify structurally identical variants
         seen_predicates: set = set()
+        # Track seen variant names to deduplicate
+        seen_names: dict = {}
         union_fields = []
         for i, t in enumerate(union_types):
             predicate = self.get_is_json_match_clause(field_name, t, for_union=True)
             # Mark if this is the first variant with this predicate structure
-            # Subsequent variants with same predicate can't be distinguished during JSON deserialization
             is_first_with_predicate = predicate not in seen_predicates
             seen_predicates.add(predicate)
+            
+            # Deduplicate variant names
+            variant_name = pascal(t.rsplit('::',1)[-1])
+            if variant_name in seen_names:
+                seen_names[variant_name] += 1
+                variant_name = f"{variant_name}{seen_names[variant_name]}"
+            else:
+                seen_names[variant_name] = 1
+            
             union_fields.append({
-                'name': pascal(t.rsplit('::',1)[-1]), 
+                'name': variant_name, 
                 'type': t, 
                 'random_value': self.generate_random_value(t),
                 'default_value': 'Default::default()',
@@ -379,7 +392,7 @@ class AvroToRust:
         dependencies = []
         if self.serde_annotation or self.avro_annotation:
             dependencies.append('serde = { version = "1.0", features = ["derive"] }')
-            dependencies.append('serde_json = "1.0"')
+        dependencies.append('serde_json = "1.0"')
         dependencies.append('chrono = { version = "0.4", features = ["serde"] }')
         dependencies.append('uuid = { version = "1.11", features = ["serde", "v4"] }')
         if self.avro_annotation or self.serde_annotation:

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotots.py

@@ -4,7 +4,7 @@ import json
 import os
 from typing import Dict, List, Set, Union
 
-from avrotize.common import build_flat_type_dict, fullname, inline_avro_references, is_generic_avro_type, is_type_with_alternate, pascal, process_template, strip_alternate_type
+from avrotize.common import build_flat_type_dict, fullname, inline_avro_references, is_generic_avro_type, is_any_value_type, is_type_with_alternate, pascal, process_template, strip_alternate_type
 from numpy import full
 
 
@@ -38,6 +38,9 @@ class AvroToTypeScript:
 
     def map_primitive_to_typescript(self, avro_type: str) -> str:
         """Map Avro primitive type to TypeScript type."""
+        # Handle AnyValue (extensible any type) regardless of namespace qualification
+        if is_any_value_type(avro_type):
+            return 'any'
         mapping = {
             'null': 'null',
             'boolean': 'boolean',

{structurize-3.5.8 → structurize-3.5.9}/avrotize/avrotoxsd.py

@@ -5,7 +5,7 @@ import xml.etree.ElementTree as ET
 from xml.etree.ElementTree import Element, SubElement, tostring
 from xml.dom import minidom
 
-from avrotize.common import is_generic_avro_type
+from avrotize.common import is_generic_avro_type, is_any_value_type
 
 class AvroToXSD:
     def __init__(self, target_namespace: str = ''):
@@ -83,6 +83,8 @@ class AvroToXSD:
         if isinstance(avro_type, dict) and 'logicalType' in avro_type and 'type' in avro_type: 
             return avro_type['type'] in {'int', 'long', 'float', 'double', 'bytes', 'string'}
         elif isinstance(avro_type, str):
+            if is_any_value_type(avro_type):
+                return True
             return avro_type in {'null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'}
         else:
             return False

{structurize-3.5.8 → structurize-3.5.9}/avrotize/common.py

@@ -60,42 +60,293 @@ def avro_namespace(name):
     return val
 
 
-def generic_type() -> list[str | dict]:
+ANY_VALUE_RECORD: dict = {
+    "type": "record",
+    "name": "AnyValue",
+    "namespace": "avrotize",
+    "doc": "Extensible record placeholder for the 'any' type. Add fields via schema evolution.",
+    "fields": []
+}
+"""Avro record definition for the extensible 'any' type. Defined once, referenced by name thereafter."""
+
+ANY_VALUE_NAME = "avrotize.AnyValue"
+"""Fully-qualified name reference for the AnyValue record."""
+
+ANY_VALUE_NAMESPACE = "avrotize"
+"""Namespace used for all AnyValue record variants."""
+
+
+def any_value_name(record_name: str = "", field_name: str = "") -> str:
+    """Generate a qualified AnyValue record name from parent record and field context.
+    
+    Produces a unique name like 'Order_data_AnyValue' so that different
+    any-typed fields can evolve their AnyValue records independently.
+    
+    Args:
+        record_name: Name of the parent record (e.g., 'Order').
+        field_name: Name of the field (e.g., 'data').
+    
+    Returns:
+        str: A qualified name like 'Order_data_AnyValue', or just 'AnyValue' if no context.
+    """
+    parts = []
+    if record_name:
+        parts.append(avro_name(record_name))
+    if field_name and field_name != record_name:
+        parts.append(avro_name(field_name))
+    if parts:
+        return "_".join(parts) + "_AnyValue"
+    return "AnyValue"
+
+
+def is_any_value_type(avro_type: str) -> bool:
+    """Check if a type name refers to an AnyValue variant (any record in the avrotize namespace)."""
+    if not isinstance(avro_type, str):
+        return False
+    return (avro_type.startswith('avrotize.') or 
+            avro_type == 'AnyValue' or 
+            avro_type.endswith('AnyValue'))
+
+
+def generic_type(*, define_any_value: bool = True, name: str = "AnyValue") -> list[str | dict]:
     """ 
-    Constructs a generic Avro type for simple types, arrays, and maps.
+    Constructs a generic Avro type as a union of all primitive types, an extensible
+    empty record, and recursive array/map types.
+
+    The record is an empty record that can be extended via Avro schema
+    evolution (adding fields with defaults). Arrays and maps reference it
+    by name, enabling infinite nesting.
+    
+    Args:
+        define_any_value: If True (default), includes the full record definition.
+            Set to False for subsequent uses in the same schema to avoid redefinition errors.
+        name: Name for the extensible record. Defaults to "AnyValue".
+            Use a unique name per field (e.g., "PayloadAnyValue") to enable
+            independent schema evolution of different any-typed fields.
     
     Returns:
-        list[str | dict]: A list of simple types, arrays, and maps.
-    """
-    simple_type_union: list[str | dict] = [
-        "null", "boolean", "int", "long", "float", "double", "bytes", "string"]
-    l2 = simple_type_union.copy()
-    l2.extend([
-        {
-            "type": "array",
-            "items": simple_type_union
-        },
-        {
-            "type": "map",
-            "values": simple_type_union
-        }])
-    l1 = simple_type_union.copy()
-    l1.extend([
-        {
-            "type": "array",
-            "items": l2
-        },
-        {
-            "type": "map",
-            "values": l2
-        }])
-    return l1
+        list[str | dict]: A union type representing 'any'.
+    """
+    fqn = f"{ANY_VALUE_NAMESPACE}.{name}"
+    record_def: dict = {
+        "type": "record",
+        "name": name,
+        "namespace": ANY_VALUE_NAMESPACE,
+        "doc": "Extensible record placeholder for the 'any' type. Add fields via schema evolution.",
+        "fields": []
+    }
+    any_value_entry: str | dict = record_def if define_any_value else fqn
+    # Inner union used in array items and map values — references record by name.
+    # Record ref comes AFTER array/map so serializers try map before the empty record.
+    inner_union: list[str | dict] = [
+        "null", "boolean", "int", "long", "float", "double", "bytes", "string",
+        {"type": "array", "items": ["null", "boolean", "int", "long", "float", "double", "bytes", "string", fqn]},
+        {"type": "map", "values": ["null", "boolean", "int", "long", "float", "double", "bytes", "string", fqn]},
+        fqn
+    ]
+    # Outer union — defines record (must come before array/map for schema parsing),
+    # then array/map use inner_union which references it by name
+    outer_union: list[str | dict] = [
+        "null", "boolean", "int", "long", "float", "double", "bytes", "string",
+        any_value_entry,
+        {"type": "array", "items": inner_union},
+        {"type": "map", "values": inner_union}
+    ]
+    return outer_union
+
+
+def deduplicate_any_value_record(schema) -> None:
+    """
+    Post-process an Avro schema to ensure each AnyValue variant is defined only once.
+    
+    Handles both the default 'AnyValue' and per-field named variants (any record
+    in the 'avrotize' namespace). Each unique name is kept at first occurrence;
+    subsequent occurrences are replaced with name references.
+    
+    Also repairs schemas where definitions were lost during union
+    merging/flattening by re-inserting definitions at the first reference point.
+    
+    Args:
+        schema: The Avro schema (dict, list, or str) to deduplicate in place.
+    """
+    import json
+    
+    if not _has_any_value_record(schema):
+        # Break aliasing: serialize/deserialize to get independent objects
+        if isinstance(schema, list):
+            fresh = json.loads(json.dumps(schema))
+            schema.clear()
+            schema.extend(fresh)
+        _repair_missing_definitions(schema)
+        return
+    
+    # Track which names have been seen (first definition kept)
+    seen_names: set = set()
+    _deduplicate_any_value_walk(schema, seen_names)
+    
+    # Break aliasing: serialize/deserialize to get independent objects at each path.
+    # This ensures the repair won't accidentally modify shared structures.
+    if isinstance(schema, list):
+        fresh = json.loads(json.dumps(schema))
+        schema.clear()
+        schema.extend(fresh)
+    elif isinstance(schema, dict):
+        fresh = json.loads(json.dumps(schema))
+        schema.clear()
+        schema.update(fresh)
+    
+    # Repair: find refs without matching defs and re-insert definitions
+    _repair_missing_definitions(schema)
+    
+    # Final dedup pass to clean up any duplicates introduced by repair
+    seen_names2: set = set()
+    _deduplicate_any_value_walk(schema, seen_names2)
+
+
+def _is_any_value_record_node(node) -> bool:
+    """Check if a dict node is an AnyValue record definition (any record in avrotize namespace)."""
+    return (isinstance(node, dict) and 
+            node.get("type") == "record" and 
+            node.get("namespace") == ANY_VALUE_NAMESPACE)
+
+
+def _has_any_value_record(node) -> bool:
+    """Check if any AnyValue record definition or reference exists in the schema."""
+    if isinstance(node, str):
+        return is_any_value_type(node)
+    elif isinstance(node, list):
+        return any(_has_any_value_record(item) for item in node)
+    elif isinstance(node, dict):
+        if _is_any_value_record_node(node):
+            return True
+        return any(_has_any_value_record(v) for v in node.values() if isinstance(v, (list, dict)))
+    return False
+
+
+def _replace_all_any_value_defs(node) -> None:
+    """Replace ALL AnyValue record definitions with name references."""
+    if isinstance(node, list):
+        for i, item in enumerate(node):
+            if _is_any_value_record_node(item):
+                node[i] = f"{ANY_VALUE_NAMESPACE}.{item['name']}"
+            else:
+                _replace_all_any_value_defs(item)
+    elif isinstance(node, dict):
+        for key, value in node.items():
+            if isinstance(value, (list, dict)):
+                _replace_all_any_value_defs(value)
+
+
+def _deduplicate_any_value_walk(node, seen_names: set) -> None:
+    """Recursively walk and deduplicate AnyValue record definitions.
+    
+    When replacing an inline definition with a name reference, moves the
+    reference to the end of the containing union so that map/array types
+    are tried first during serialization union resolution.
+    """
+    if isinstance(node, list):
+        # Use index-based iteration to safely handle list mutations
+        i = 0
+        while i < len(node):
+            item = node[i]
+            if _is_any_value_record_node(item):
+                fqn = f"{ANY_VALUE_NAMESPACE}.{item['name']}"
+                if fqn in seen_names:
+                    # Replace with name reference and move to end of the union
+                    node.pop(i)
+                    node.append(fqn)
+                    # Don't increment i - next item shifted into current position
+                else:
+                    seen_names.add(fqn)
+                    i += 1
+            else:
+                _deduplicate_any_value_walk(item, seen_names)
+                i += 1
+    elif isinstance(node, dict):
+        for key, value in node.items():
+            if isinstance(value, (list, dict)):
+                _deduplicate_any_value_walk(value, seen_names)
+
+
+def _repair_missing_definitions(schema) -> None:
+    """Re-insert AnyValue definitions where refs exist but defs were lost during merging.
+    
+    Scans the schema for all AnyValue name references (strings like 'avrotize.XxxAnyValue')
+    and all AnyValue record definitions. For any name that has references but no definition,
+    replaces the FIRST reference with a full record definition inline.
+    """
+    # Collect all defined names and all referenced names
+    defined_names: set = set()
+    referenced_names: set = set()
+    _collect_any_value_names(schema, defined_names, referenced_names)
+    
+    # Find names that are referenced but not defined
+    missing = referenced_names - defined_names
+    if not missing:
+        return
+    
+    # For each missing name, replace the first reference with a definition
+    for fqn in missing:
+        name = fqn.replace(f"{ANY_VALUE_NAMESPACE}.", "", 1)
+        record_def = {
+            "type": "record",
+            "name": name,
+            "namespace": ANY_VALUE_NAMESPACE,
+            "doc": "Extensible record placeholder for the 'any' type. Add fields via schema evolution.",
+            "fields": []
+        }
+        _replace_first_ref_with_def(schema, fqn, record_def)
+
+
+def _collect_any_value_names(node, defined: set, referenced: set) -> None:
+    """Collect all AnyValue definition names and reference names in the schema."""
+    if isinstance(node, str):
+        if node.startswith(f"{ANY_VALUE_NAMESPACE}.") and node.endswith("AnyValue"):
+            referenced.add(node)
+    elif isinstance(node, list):
+        for item in node:
+            _collect_any_value_names(item, defined, referenced)
+    elif isinstance(node, dict):
+        if _is_any_value_record_node(node) and node.get("name", "").endswith("AnyValue"):
+            defined.add(f"{ANY_VALUE_NAMESPACE}.{node['name']}")
+        for v in node.values():
+            if isinstance(v, (list, dict, str)):
+                _collect_any_value_names(v, defined, referenced)
+
+
+def _replace_first_ref_with_def(node, fqn: str, record_def: dict) -> bool:
+    """Replace the first occurrence of a name reference string with a record definition.
+    
+    Returns True if replacement was made, False otherwise.
+    """
+    if isinstance(node, list):
+        for i, item in enumerate(node):
+            if item == fqn:
+                node[i] = record_def
+                return True
+            elif isinstance(item, (list, dict)):
+                if _replace_first_ref_with_def(item, fqn, record_def):
+                    return True
+    elif isinstance(node, dict):
+        for key, value in node.items():
+            if value == fqn:
+                node[key] = record_def
+                return True
+            elif isinstance(value, (list, dict)):
+                if _replace_first_ref_with_def(value, fqn, record_def):
+                    return True
+    return False
+
 
 
 def is_generic_avro_type(avro_type: list) -> bool:
     """
     Check if the given Avro type is a generic type.
 
+    Recognizes the current AnyValue-based format (with any name in the avrotize
+    namespace), the default AnyValue format, and the legacy 2-level nested 
+    primitives union for backward compatibility.
+
     Args:
         avro_type (Union[str, Dict[str, Any]]): The Avro type to check.
 
@@ -104,8 +355,46 @@ def is_generic_avro_type(avro_type: list) -> bool:
     """
     if isinstance(avro_type, str) or isinstance(avro_type, dict):
         return False
-    compare_type = generic_type()
-    return Compare().check(avro_type, compare_type) == NO_DIFF
+    # Check current default format (with full definition and with name reference)
+    if Compare().check(avro_type, generic_type(define_any_value=True)) == NO_DIFF:
+        return True
+    if Compare().check(avro_type, generic_type(define_any_value=False)) == NO_DIFF:
+        return True
+    # Check for per-field named variant: look for any avrotize.* record in the union
+    if _is_any_value_union_structure(avro_type):
+        return True
+    # Check legacy format (2-level nested primitives union without AnyValue)
+    if Compare().check(avro_type, _legacy_generic_type()) == NO_DIFF:
+        return True
+    return False
+
+
+def _is_any_value_union_structure(avro_type: list) -> bool:
+    """Check if a union has the generic_type structure with any avrotize.* record."""
+    # Must have at least 11 elements (8 primitives + record + array + map)
+    if len(avro_type) < 11:
+        return False
+    # Check primitives prefix
+    expected_primitives = ["null", "boolean", "int", "long", "float", "double", "bytes", "string"]
+    if avro_type[:8] != expected_primitives:
+        return False
+    # Look for an avrotize namespace record (inline def or name ref) in remaining elements
+    for item in avro_type[8:]:
+        if isinstance(item, dict) and _is_any_value_record_node(item):
+            return True
+        if isinstance(item, str) and item.startswith(f"{ANY_VALUE_NAMESPACE}."):
+            return True
+    return False
+
+
+def _legacy_generic_type() -> list[str | dict]:
+    """Construct the legacy generic Avro type (2-level nested primitives without AnyValue)."""
+    simple = ["null", "boolean", "int", "long", "float", "double", "bytes", "string"]
+    l2 = simple.copy()
+    l2.extend([{"type": "array", "items": simple}, {"type": "map", "values": simple}])
+    l1 = simple.copy()
+    l1.extend([{"type": "array", "items": l2}, {"type": "map", "values": l2}])
+    return l1
 
 
 def is_generic_json_type(json_type: Dict[str, Any] | List[Dict[str, Any] | str] | str) -> bool:

{structurize-3.5.8 → structurize-3.5.9}/avrotize/jsonstoavro.py

@@ -12,7 +12,7 @@ import jsonpointer
 from jsonpointer import JsonPointerException
 import requests
 
-from avrotize.common import avro_name, avro_namespace, find_schema_node, generic_type, set_schema_node
+from avrotize.common import avro_name, avro_namespace, deduplicate_any_value_record, find_schema_node, generic_type, set_schema_node
 from avrotize.dependency_resolver import inline_dependencies_of, sort_messages_by_dependencies
 
 primitive_types = ['null', 'string', 'int',
@@ -2124,6 +2124,8 @@ class JsonToAvroConverter:
         # drop the file name from the parsed URL to get the base URI
         avro_schema = self.jsons_to_avro(
             json_schema, namespace, parsed_url.geturl())
+        # Deduplicate AnyValue record definitions (keep only the first one)
+        deduplicate_any_value_record(avro_schema)
         if len(avro_schema) == 1:
             avro_schema = avro_schema[0]
 

{structurize-3.5.8 → structurize-3.5.9}/avrotize/jstructtoavro.py

@@ -8,6 +8,8 @@ This is the reverse operation of avrotojstruct.py.
 import json
 from typing import Any, Dict, List, Union, Optional
 
+from avrotize.common import ANY_VALUE_RECORD, any_value_name, deduplicate_any_value_record, generic_type
+
 
 class JsonStructureToAvro:
     """
@@ -54,9 +56,12 @@ class JsonStructureToAvro:
                 # Filter out abstract types
                 concrete_types = [schema for schema in self.converted_types.values() 
                                  if not (schema.get('type') == 'null' and 'Abstract type' in schema.get('doc', ''))]
-                return [root_schema] + concrete_types if concrete_types else root_schema
+                result = [root_schema] + concrete_types if concrete_types else root_schema
+            else:
+                result = root_schema
             
-            return root_schema
+            deduplicate_any_value_record(result)
+            return result
         
         if not root_ref:
             raise ValueError("JSON Structure document must have either 'type' or '$root' property")
@@ -79,10 +84,13 @@ class JsonStructureToAvro:
         
         # Return single schema or list depending on how many types were defined
         if len(self.converted_types) == 1:
-            return root_schema
+            result = root_schema
         else:
             # Return all schemas as a list
-            return list(self.converted_types.values())
+            result = list(self.converted_types.values())
+        
+        deduplicate_any_value_record(result)
+        return result
     
     def _flatten_definitions(self, definitions: Dict[str, Any], prefix: str = '') -> Dict[str, Dict[str, Any]]:
         """
@@ -618,7 +626,7 @@ class JsonStructureToAvro:
         return avro_record
     
     def _convert_any(self, schema: Dict[str, Any], namespace: Optional[str], name: str) -> Dict[str, Any]:
-        """Convert JSON Structure 'any' type to Avro union of all basic types."""
+        """Convert JSON Structure 'any' type to Avro union of all basic types plus extensible record."""
         avro_record: Dict[str, Any] = {
             'type': 'record',
             'name': name
@@ -632,11 +640,10 @@ class JsonStructureToAvro:
         else:
             avro_record['doc'] = 'Any type'
         
-        # In Avro, 'any' can be represented as a union of all basic types
-        # or as a string containing JSON
+        # Use the generic_type() which includes primitives, AnyValue record, arrays, and maps
         avro_record['fields'] = [{
             'name': 'value',
-            'type': ['null', 'boolean', 'int', 'long', 'float', 'double', 'string', 'bytes']
+            'type': generic_type(name=any_value_name(name, 'value'))
         }]
         
         return avro_record
@@ -731,8 +738,8 @@ class JsonStructureToAvro:
         
         # Handle any types  
         if type_value == 'any':
-            # Return union of all basic types
-            return ['null', 'boolean', 'int', 'long', 'float', 'double', 'string', 'bytes']
+            # Return union of all basic types + extensible AnyValue record + arrays/maps
+            return generic_type()
         
         if type_value == 'array':
             return {

{structurize-3.5.8 → structurize-3.5.9}/avrotize/structuretocpp.py

@@ -284,6 +284,10 @@ class StructureToCpp:
         properties = structure_schema.get('properties', {})
         required_props = structure_schema.get('required', [])
         
+        # Track fields that need string-based JSON serialization
+        string_json_fields = []  # (field_name, original_name, field_type, source_type)
+        all_field_info = []  # (field_name, original_name, field_type, source_type)
+        
         for prop_name, prop_schema in properties.items():
             field_name = self.safe_identifier(prop_name)
             is_required = prop_name in required_props if not isinstance(required_props, list) or len(required_props) == 0 or not isinstance(required_props[0], list) else any(prop_name in req_set for req_set in required_props)
@@ -291,6 +295,12 @@ class StructureToCpp:
             # Convert to C++ type
             field_type = self.convert_structure_type_to_cpp(class_name, field_name, prop_schema, schema_namespace, nullable=not is_required)
             
+            # Get source type
+            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema, dict) and isinstance(prop_schema.get('type'), str) else 'object'
+            all_field_info.append((field_name, prop_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))
+            
             # Add documentation
             if 'description' in prop_schema or 'doc' in prop_schema:
                 field_doc = prop_schema.get('description', prop_schema.get('doc', ''))
@@ -310,6 +320,38 @@ 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:
+            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:
+                if stype in ('int64', 'uint64', 'int128', 'uint128'):
+                    if 'optional' in ftype:
+                        class_definition += f"{INDENT}{INDENT}if (v.{fname}.has_value()) j[\"{orig_name}\"] = std::to_string(v.{fname}.value()); else j[\"{orig_name}\"] = nullptr;\n"
+                    else:
+                        class_definition += f"{INDENT}{INDENT}j[\"{orig_name}\"] = std::to_string(v.{fname});\n"
+                elif stype == 'decimal':
+                    # decimal is already std::string in C++, serializes as string naturally
+                    class_definition += f"{INDENT}{INDENT}j[\"{orig_name}\"] = v.{fname};\n"
+                else:
+                    class_definition += f"{INDENT}{INDENT}j[\"{orig_name}\"] = v.{fname};\n"
+            class_definition += f"{INDENT}}}\n"
+            
+            class_definition += f"\n{INDENT}friend void from_json(const nlohmann::json& j, {class_name}& v) {{\n"
+            for fname, orig_name, ftype, stype in all_field_info:
+                if stype in ('int64', 'uint64', 'int128', 'uint128'):
+                    cpp_parse = 'std::stoll' if stype in ('int64',) else 'std::stoull' if stype in ('uint64',) else 'std::stoll'
+                    if 'optional' in ftype:
+                        class_definition += f"{INDENT}{INDENT}if (j.contains(\"{orig_name}\") && !j[\"{orig_name}\"].is_null()) v.{fname} = {cpp_parse}(j[\"{orig_name}\"].get<std::string>()); else v.{fname} = std::nullopt;\n"
+                    else:
+                        class_definition += f"{INDENT}{INDENT}if (j.contains(\"{orig_name}\")) v.{fname} = {cpp_parse}(j[\"{orig_name}\"].get<std::string>());\n"
+                else:
+                    if 'optional' in ftype:
+                        class_definition += f"{INDENT}{INDENT}if (j.contains(\"{orig_name}\") && !j[\"{orig_name}\"].is_null()) v.{fname} = j[\"{orig_name}\"].get<{ftype.replace('std::optional<', '').rstrip('>')}>();\n"
+                    else:
+                        class_definition += f"{INDENT}{INDENT}if (j.contains(\"{orig_name}\")) j.at(\"{orig_name}\").get_to(v.{fname});\n"
+            class_definition += f"{INDENT}}}\n"
+        
         class_definition += "};\n\n"
 
         # Create includes
@@ -571,6 +613,7 @@ class StructureToCpp:
             if "std::optional" in definition:
                 file.write("#include <optional>\n")
             file.write("#include <stdexcept>\n")
+            file.write("#include <string>\n")
             if "std::chrono" in definition:
                 file.write("#include <chrono>\n")
             if "boost::uuid" in definition:

{structurize-3.5.8 → structurize-3.5.9}/avrotize/structuretogo.py

@@ -329,10 +329,12 @@ class StructureToGo:
             if not is_required and not field_type.startswith('*') and not field_type.startswith('[') and not field_type.startswith('map[') and field_type != 'interface{}':
                 field_type = f'*{field_type}'
             
+            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
             fields.append({
                 'name': pascal(prop_name),
                 'type': field_type,
-                'original_name': prop_name
+                'original_name': prop_name,
+                'source_type': source_type
             })
 
         # Get imports needed

{structurize-3.5.8 → structurize-3.5.9}/avrotize/structuretojava.py

@@ -435,10 +435,12 @@ class StructureToJava:
                 prop_type = prop_type[:-1]
             const_value = self.format_const_value(const_val, prop_type)
         
+        source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
         return {
             'name': safe_field_name,
             'original_name': prop_name,
             'type': field_type.type_name,
+            'source_type': source_type,
             'docstring': doc,
             'is_const': is_const,
             'const_value': const_value

{structurize-3.5.8 → structurize-3.5.9}/avrotize/structuretorust.py

@@ -324,10 +324,12 @@ class StructureToRust:
             
             serde_rename = field_name != original_field_name
             
+            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
             fields.append({
                 'original_name': original_field_name,
                 'name': field_name,
                 'type': prop_type,
+                'source_type': source_type,
                 'serde_rename': serde_rename,
                 'random_value': self.generate_random_value(prop_type)
             })

{structurize-3.5.8 → structurize-3.5.9}/avrotize/structuretots.py

@@ -342,11 +342,13 @@ class StructureToTypeScript:
                         is_enum = True
                         break
             
+            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema, dict) and isinstance(prop_schema.get('type'), str) else 'object'
             fields.append({
                 'name': self.safe_name(prop_name),
                 'original_name': prop_name,
                 'type': field_type,
                 'type_no_null': field_type_no_null,
+                'source_type': source_type,
                 'is_required': is_required,
                 'is_optional': is_optional,
                 'is_primitive': self.is_typescript_primitive(field_type_no_null.replace('[]', '')),

{structurize-3.5.8 → structurize-3.5.9}/avrotize/xsdtoavro.py

@@ -8,7 +8,7 @@ from typing import Dict, List, Tuple
 import xml.etree.ElementTree as ET
 import json
 from urllib.parse import urlparse
-from avrotize.common import avro_namespace, generic_type
+from avrotize.common import avro_namespace, deduplicate_any_value_record, generic_type
 
 from avrotize.dependency_resolver import inline_dependencies_of, sort_messages_by_dependencies
 
@@ -381,6 +381,7 @@ class XSDToAvro:
                 element, namespaces))
 
         avro_schema = sort_messages_by_dependencies(avro_schema)
+        deduplicate_any_value_record(avro_schema)
         if len(avro_schema) == 1:
             return avro_schema[0]
         else:

{structurize-3.5.8 → structurize-3.5.9/structurize.egg-info}/PKG-INFO

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