avrotize 2.21.0__py3-none-any.whl → 2.22.0__py3-none-any.whl

avrotize/avrotorust.py

@@ -144,12 +144,15 @@ class AvroToRust:
             field_name = self.safe_identifier(snake(original_field_name))
             field_type = self.convert_avro_type_to_rust(field_name, field['type'], parent_namespace)
             serde_rename = field_name != original_field_name
+            # Check if this is a generated type (enum, union, or record) where random values may match default
+            is_generated_type = field_type in self.generated_types_rust_package or '::' in field_type
             fields.append({
                 'original_name': original_field_name,
                 'name': field_name,
                 'type': field_type,
                 'serde_rename': serde_rename,
-                'random_value': self.generate_random_value(field_type)
+                'random_value': self.generate_random_value(field_type),
+                'is_generated_type': is_generated_type
             })
         
         struct_name = self.safe_identifier(pascal(avro_schema['name']))
@@ -187,28 +190,51 @@ class AvroToRust:
     def get_is_json_match_clause(self, field_name: str, field_type: str, for_union=False) -> str:
         """Generates the is_json_match clause for a field"""
         ref = f'node[\"{field_name}\"]' if not for_union else 'node'
-        if field_type == 'String' or field_type == 'Option<String>':
-            return f"{ref}.is_string()"
-        elif field_type == 'bool' or field_type == 'Option<bool>':
-            return f"{ref}.is_boolean()"
-        elif field_type == 'i32' or field_type == 'Option<i32>':
-            return f"{ref}.is_i64()"
-        elif field_type == 'i64' or field_type == 'Option<i64>':
-            return f"{ref}.is_i64()"
-        elif field_type == 'f32' or field_type == 'Option<f32>':
-            return f"{ref}.is_f64()"
-        elif field_type == 'f64' or field_type == 'Option<f64>':
-            return f"{ref}.is_f64()"
-        elif field_type == 'Vec<u8>' or field_type == 'Option<Vec<u8>>':
-            return f"{ref}.is_array()"
-        elif field_type == 'serde_json::Value' or field_type == 'std::collections::HashMap<String, String>':
-            return f"{ref}.is_object()"
-        elif field_type.startswith('std::collections::HashMap<String, '):
-            return f"{ref}.is_object()"
-        elif field_type.startswith('Vec<'):
-            return f"{ref}.is_array()"
+        
+        # Check if type is optional - if so, we need to allow null values
+        is_optional = field_type.startswith('Option<')
+        base_type = field_type[7:-1] if is_optional else field_type
+        null_check = f" || {ref}.is_null()" if is_optional else ""
+        
+        # serde_json::Value can be any JSON type, so always return true
+        if base_type == 'serde_json::Value':
+            return "true"
+        
+        if base_type == 'String':
+            return f"({ref}.is_string(){null_check})"
+        elif base_type == 'bool':
+            return f"({ref}.is_boolean(){null_check})"
+        elif base_type == 'i32':
+            return f"({ref}.is_i64(){null_check})"
+        elif base_type == 'i64':
+            return f"({ref}.is_i64(){null_check})"
+        elif base_type == 'f32':
+            return f"({ref}.is_f64(){null_check})"
+        elif base_type == 'f64':
+            return f"({ref}.is_f64(){null_check})"
+        elif base_type == 'Vec<u8>':
+            return f"({ref}.is_array(){null_check})"
+        elif base_type == 'std::collections::HashMap<String, String>':
+            return f"({ref}.is_object(){null_check})"
+        elif base_type.startswith('std::collections::HashMap<String, '):
+            return f"({ref}.is_object(){null_check})"
+        elif base_type.startswith('Vec<'):
+            return f"({ref}.is_array(){null_check})"
+        # chrono types - check for string (ISO 8601 format) or number (timestamp)
+        elif 'chrono::NaiveDateTime' in base_type or 'NaiveDateTime' in base_type:
+            return f"({ref}.is_string() || {ref}.is_i64(){null_check})"
+        elif 'chrono::NaiveDate' in base_type or 'NaiveDate' in base_type:
+            return f"({ref}.is_string() || {ref}.is_i64(){null_check})"
+        elif 'chrono::NaiveTime' in base_type or 'NaiveTime' in base_type:
+            return f"({ref}.is_string() || {ref}.is_i64(){null_check})"
+        # uuid type - check for string
+        elif 'uuid::Uuid' in base_type or 'Uuid' in base_type:
+            return f"({ref}.is_string(){null_check})"
         else:
-            return f"{field_type}::is_json_match(&{ref})"
+            # Custom types - call their is_json_match method
+            if is_optional:
+                return f"({base_type}::is_json_match(&{ref}) || {ref}.is_null())"
+            return f"{base_type}::is_json_match(&{ref})"
 
 
     def generate_enum(self, avro_schema: Dict, parent_namespace: str) -> str:
@@ -250,17 +276,29 @@ class AvroToRust:
         ns = namespace.replace('.', '::').lower()
         union_enum_name = pascal(field_name) + 'Union'
         union_types = [self.convert_avro_type_to_rust(field_name + "Option" + str(i), t, namespace) for i, t in enumerate(avro_type) if t != 'null']
-        union_fields = [
-            {
+        
+        # Track seen predicates to identify structurally identical variants
+        seen_predicates: set = set()
+        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)
+            union_fields.append({
                 'name': pascal(t.rsplit('::',1)[-1]), 
                 'type': t, 
                 'random_value': self.generate_random_value(t),
                 'default_value': 'Default::default()',
-                'json_match_predicate': self.get_is_json_match_clause(field_name, t, for_union=True),
-            } for i, t in enumerate(union_types)]
+                'json_match_predicate': predicate,
+                'is_first_with_predicate': is_first_with_predicate,
+            })
+        
         qualified_union_enum_name = self.safe_package(self.concat_package(ns, union_enum_name))
         context = {
             'serde_annotation': self.serde_annotation,
+            'avro_annotation': self.avro_annotation,
             'union_enum_name': union_enum_name,
             'union_fields': union_fields,
             'json_match_predicates': [self.get_is_json_match_clause(f['name'], f['type'], for_union=True) for f in union_fields]

avrotize/structuretocsharp.py

@@ -143,6 +143,35 @@ class StructureToCSharp:
         ]
         return word in reserved_words
 
+    def safe_identifier(self, name: str, class_name: str = '', fallback_prefix: str = 'field') -> str:
+        """Converts a name to a safe C# identifier.
+        
+        Handles:
+        - Reserved words (prepend @)
+        - Numeric prefixes (prepend _)
+        - Special characters (replace with _)
+        - All-special-char names (use fallback_prefix)
+        - Class name collision (append _)
+        """
+        import re
+        # Replace invalid characters with underscores
+        safe = re.sub(r'[^a-zA-Z0-9_]', '_', str(name))
+        # Remove leading/trailing underscores from sanitization
+        safe = safe.strip('_') if safe != name else safe
+        # If nothing left after removing special chars, use fallback
+        if not safe or not re.match(r'^[a-zA-Z_@]', safe):
+            if safe and re.match(r'^[0-9]', safe):
+                safe = '_' + safe  # Numeric prefix
+            else:
+                safe = fallback_prefix + '_' + (safe if safe else 'unnamed')
+        # Handle reserved words with @ prefix
+        if self.is_csharp_reserved_word(safe):
+            safe = '@' + safe
+        # Handle class name collision
+        if class_name and safe == class_name:
+            safe = safe + '_'
+        return safe
+
     def is_csharp_primitive_type(self, csharp_type: str) -> bool:
         """ Checks if a type is a C# primitive type """
         if csharp_type.endswith('?'):
@@ -416,16 +445,18 @@ class StructureToCSharp:
         """ Generates a property for a class """
         property_definition = ''
         
-        # Resolve property name
-        field_name = prop_name
-        if self.is_csharp_reserved_word(field_name):
-            field_name = f"@{field_name}"
+        # Resolve property name using safe_identifier for special chars, numeric prefixes, etc.
+        field_name = self.safe_identifier(prop_name, class_name)
         if self.pascal_properties:
-            field_name_cs = pascal(field_name)
+            field_name_cs = pascal(field_name.lstrip('@'))
+            # Re-check for class name collision after pascal casing
+            if field_name_cs == class_name:
+                field_name_cs += "_"
         else:
             field_name_cs = field_name
-        if field_name_cs == class_name:
-            field_name_cs += "_"
+        
+        # Track if field name differs from original for JSON annotation
+        needs_json_annotation = field_name_cs != prop_name
         
         # Check if this is a const field
         if 'const' in prop_schema:
@@ -442,9 +473,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 field_name != field_name_cs:
+            if needs_json_annotation:
                 property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{prop_name}")]\n'
-            if self.newtonsoft_json_annotation and field_name != field_name_cs:
+            if self.newtonsoft_json_annotation and needs_json_annotation:
                 property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{prop_name}")]\n'
             
             # Add XML element annotation if enabled
@@ -473,9 +504,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 field_name != field_name_cs:
+        if needs_json_annotation:
             property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{prop_name}")]\n'
-        if self.newtonsoft_json_annotation and field_name != field_name_cs:
+        if self.newtonsoft_json_annotation and needs_json_annotation:
             property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{prop_name}")]\n'
         
         # Add XML element annotation if enabled

avrotize/structuretodb.py

@@ -443,6 +443,27 @@ def structure_type_to_sql_type(structure_type: Any, dialect: str) -> str:
         struct_type = structure_type.get("type", "string")
         if struct_type in ["array", "set", "map", "object", "choice", "tuple"]:
             return type_map[dialect][struct_type]
+        
+        # Handle string type with maxLength annotation
+        if struct_type == "string" and "maxLength" in structure_type:
+            max_length = structure_type["maxLength"]
+            if dialect == "sqlserver" or dialect == "sqlanywhere":
+                return f"NVARCHAR({max_length})"
+            elif dialect in ["postgres", "redshift", "db2"]:
+                return f"VARCHAR({max_length})"
+            elif dialect in ["mysql", "mariadb"]:
+                return f"VARCHAR({max_length})"
+            elif dialect == "sqlite":
+                return f"VARCHAR({max_length})"
+            elif dialect == "oracle":
+                return f"VARCHAR2({max_length})"
+            elif dialect == "bigquery":
+                return f"STRING({max_length})"
+            elif dialect == "snowflake":
+                return f"VARCHAR({max_length})"
+            else:
+                return f"VARCHAR({max_length})"
+        
         return structure_type_to_sql_type(struct_type, dialect)
     
     return type_map.get(dialect, type_map["postgres"])["string"]

avrotize/structuretogo.py

@@ -16,8 +16,15 @@ INDENT = '    '
 class StructureToGo:
     """ Converts JSON Structure schema to Go structs """
 
+    # Go reserved keywords that cannot be used as package names
+    GO_RESERVED_WORDS = [
+        'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct', 'chan',
+        'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type', 'continue', 'for',
+        'import', 'return', 'var',
+    ]
+
     def __init__(self, base_package: str = '') -> None:
-        self.base_package = base_package
+        self.base_package = self._safe_package_name(base_package) if base_package else base_package
         self.output_dir = os.getcwd()
         self.json_annotation = False
         self.avro_annotation = False
@@ -31,17 +38,37 @@ class StructureToGo:
         self.structs: List[Dict] = []
         self.enums: List[Dict] = []
 
-    def safe_identifier(self, name: str) -> str:
-        """Converts a name to a safe Go identifier"""
-        reserved_words = [
-            'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct', 'chan',
-            'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type', 'continue', 'for',
-            'import', 'return', 'var',
-        ]
-        if name in reserved_words:
+    def _safe_package_name(self, name: str) -> str:
+        """Converts a name to a safe Go package name"""
+        if name in self.GO_RESERVED_WORDS:
             return f"{name}_"
         return name
 
+    def safe_identifier(self, name: str, fallback_prefix: str = 'field') -> str:
+        """Converts a name to a safe Go identifier.
+        
+        Handles:
+        - Reserved words (append _)
+        - Numeric prefixes (prepend _)
+        - Special characters (replace with _)
+        - All-special-char names (use fallback_prefix)
+        """
+        import re
+        # Replace invalid characters with underscores
+        safe = re.sub(r'[^a-zA-Z0-9_]', '_', str(name))
+        # Remove leading/trailing underscores from sanitization
+        safe = safe.strip('_') if safe != name else safe
+        # If nothing left after removing special chars, use fallback
+        if not safe or not re.match(r'^[a-zA-Z_]', safe):
+            if safe and re.match(r'^[0-9]', safe):
+                safe = '_' + safe  # Numeric prefix
+            else:
+                safe = fallback_prefix + '_' + (safe if safe else 'unnamed')
+        # Handle reserved words
+        if safe in self.GO_RESERVED_WORDS:
+            safe = safe + '_'
+        return safe
+
     def go_type_name(self, name: str, namespace: str = '') -> str:
         """Returns a qualified name for a Go struct or enum"""
         if namespace:
@@ -675,7 +702,8 @@ class StructureToGo:
     def convert(self, structure_schema_path: str, output_dir: str):
         """Converts JSON Structure schema to Go"""
         if not self.base_package:
-            self.base_package = os.path.splitext(os.path.basename(structure_schema_path))[0].replace('-', '_').lower()
+            pkg_name = os.path.splitext(os.path.basename(structure_schema_path))[0].replace('-', '_').lower()
+            self.base_package = self._safe_package_name(pkg_name)
 
         with open(structure_schema_path, 'r', encoding='utf-8') as file:
             schema = json.load(file)

avrotize/structuretojava/pom.xml.jinja

@@ -22,5 +22,10 @@
             <artifactId>jackson-annotations</artifactId>
             <version>${jackson.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-jsr310</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
     </dependencies>
 </project>

avrotize/structuretojava.py

@@ -71,13 +71,34 @@ class StructureToJava:
             self.is_class = is_class
             self.is_enum = is_enum
 
-    def safe_identifier(self, name: str, class_name: str = '') -> str:
-        """Converts a name to a safe Java identifier"""
-        if is_java_reserved_word(name):
-            return f"_{name}"
-        if class_name and name == class_name:
-            return f"{name}_"
-        return name
+    def safe_identifier(self, name: str, class_name: str = '', fallback_prefix: str = 'field') -> str:
+        """Converts a name to a safe Java identifier.
+        
+        Handles:
+        - Reserved words (prepend _)
+        - Numeric prefixes (prepend _)
+        - Special characters (replace with _)
+        - All-special-char names (use fallback_prefix)
+        - Class name collision (append _)
+        """
+        import re
+        # Replace invalid characters with underscores
+        safe = re.sub(r'[^a-zA-Z0-9_]', '_', str(name))
+        # Remove leading/trailing underscores from sanitization
+        safe = safe.strip('_') if safe != name else safe
+        # If nothing left after removing special chars, use fallback
+        if not safe or not re.match(r'^[a-zA-Z_]', safe):
+            if safe and re.match(r'^[0-9]', safe):
+                safe = '_' + safe  # Numeric prefix
+            else:
+                safe = fallback_prefix + '_' + (safe if safe else 'unnamed')
+        # Handle reserved words
+        if is_java_reserved_word(safe):
+            safe = '_' + safe
+        # Handle class name collision
+        if class_name and safe == class_name:
+            safe = safe + '_'
+        return safe
 
     def safe_package(self, packageName: str) -> str:
         """Converts a name to a safe Java identifier by checking each path segment"""
@@ -384,7 +405,12 @@ class StructureToJava:
             field_count=len(field_names)
         )
         
-        class_definition = class_definition.rstrip() + equals_hashcode + "\n}\n"
+        # Generate createTestInstance() method for testing (only for non-abstract classes)
+        create_test_instance = ''
+        if not is_abstract:
+            create_test_instance = self.generate_create_test_instance_method(class_name, fields, schema_namespace)
+        
+        class_definition = class_definition.rstrip() + create_test_instance + equals_hashcode + "\n}\n"
 
         if write_file:
             self.write_to_file(package, class_name, class_definition)
@@ -455,6 +481,86 @@ class StructureToJava:
             return str(value)
         return f"/* unsupported const value */"
 
+    def get_test_value(self, java_type: str) -> str:
+        """ Get a test value for a Java type """
+        # Handle arrays/lists
+        if java_type.startswith("List<") or java_type.startswith("ArrayList<"):
+            return "new java.util.ArrayList<>()"
+        if java_type.startswith("Map<"):
+            return "new java.util.HashMap<>()"
+        if java_type.endswith("[]"):
+            return f"new {java_type[:-2]}[0]"
+        
+        # Primitive test values
+        test_values = {
+            'String': '"test-string"',
+            'string': '"test-string"',
+            'int': '42',
+            'Integer': '42',
+            'long': '42L',
+            'Long': '42L',
+            'double': '3.14',
+            'Double': '3.14',
+            'float': '3.14f',
+            'Float': '3.14f',
+            'boolean': 'true',
+            'Boolean': 'true',
+            'byte': '(byte)0',
+            'Byte': '(byte)0',
+            'short': '(short)0',
+            'Short': '(short)0',
+            'BigInteger': 'java.math.BigInteger.ZERO',
+            'BigDecimal': 'java.math.BigDecimal.ZERO',
+            'byte[]': 'new byte[0]',
+            'LocalDate': 'java.time.LocalDate.now()',
+            'LocalTime': 'java.time.LocalTime.now()',
+            'Instant': 'java.time.Instant.now()',
+            'Duration': 'java.time.Duration.ZERO',
+            'UUID': 'java.util.UUID.randomUUID()',
+            'URI': 'java.net.URI.create("http://example.com")',
+            'Object': 'new Object()',
+            'void': 'null',
+            'Void': 'null',
+        }
+        
+        if java_type in test_values:
+            return test_values[java_type]
+        
+        # Check if it's a generated type (enum or class)
+        if java_type in self.generated_types_java_package:
+            type_kind = self.generated_types_java_package[java_type]
+            if type_kind == "enum":
+                return f'{java_type}.values()[0]'
+            elif type_kind == "class":
+                return f'{java_type}.createTestInstance()'
+        
+        # Default: try to instantiate
+        return f'new {java_type}()'
+
+    def generate_create_test_instance_method(self, class_name: str, fields: List[Dict], parent_package: str) -> str:
+        """ Generates a static createTestInstance method that creates a fully initialized instance """
+        method = f"\n{INDENT}/**\n{INDENT} * Creates a test instance with all required fields populated\n{INDENT} * @return a fully initialized test instance\n{INDENT} */\n"
+        method += f"{INDENT}public static {class_name} createTestInstance() {{\n"
+        method += f"{INDENT*2}{class_name} instance = new {class_name}();\n"
+        
+        for field in fields:
+            # Skip const fields
+            if field.get('is_const', False):
+                continue
+            
+            field_name = field['name']
+            field_type = field['type']
+            
+            # Get a test value for this field
+            test_value = self.get_test_value(field_type)
+            
+            # Setter name: set{Pascal(field_name)}
+            method += f"{INDENT*2}instance.set{pascal(field_name)}({test_value});\n"
+        
+        method += f"{INDENT*2}return instance;\n"
+        method += f"{INDENT}}}\n"
+        return method
+
     def generate_enum(self, structure_schema: Dict, field_name: str, parent_package: str, write_file: bool) -> JavaType:
         """ Generates a Java enum from JSON Structure enum schema """
         

avrotize/structuretopython/dataclass_core.jinja

@@ -1,6 +1,7 @@
 """ {{ class_name }} dataclass. """
 
 # pylint: disable=too-many-lines, too-many-locals, too-many-branches, too-many-statements, too-many-arguments, line-too-long, wildcard-import
+from __future__ import annotations
 
 {%- if avro_annotation or dataclasses_json_annotation %}
 import io
@@ -69,7 +70,7 @@ class {{ class_name }}{% if base_class or is_abstract %}({% if base_class %}{{ b
     {% endif %}
     {% for field in fields %}
     {%- set isdate = field.type == "datetime.datetime" or field.type == "typing.Optional[datetime.datetime]" %}
-    {{ field.name }}: {{ field.type }}=dataclasses.field(kw_only=True{% if dataclasses_json_annotation %}, metadata=dataclasses_json.config(field_name="{{ field.original_name }}"{%- if isdate -%}, encoder=lambda d: datetime.datetime.isoformat(d) if d else None, decoder=lambda d:datetime.datetime.fromisoformat(d) if d else None, mm_field=fields.DateTime(format='iso'){%- endif -%}){%- endif %})
+    {{ field.name }}: {{ field.type }}=dataclasses.field(kw_only=True{% if dataclasses_json_annotation %}, metadata=dataclasses_json.config(field_name="{{ field.original_name }}"{%- if isdate -%}, encoder=lambda d: d.isoformat() if isinstance(d, datetime.datetime) else d if d else None, decoder=lambda d: datetime.datetime.fromisoformat(d) if isinstance(d, str) else d if d else None, mm_field=fields.DateTime(format='iso'){%- endif -%}){%- endif %})
     {%- endfor %}
 
     @classmethod