structurize 3.5.8__tar.gz → 3.5.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.8
+Version: 3.5.10
 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.10}/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.10'
+__version_tuple__ = version_tuple = (3, 5, 10)
 
-__commit_id__ = commit_id = 'g3100f0e10'
+__commit_id__ = commit_id = 'g974039ac5'

{structurize-3.5.8 → structurize-3.5.10}/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.10}/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.10}/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.10}/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.10}/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.10}/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.10}/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.10}/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.10}/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.10}/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.10}/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