avrotize 2.21.1__py3-none-any.whl → 2.22.1__py3-none-any.whl

avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.21.1'
-__version_tuple__ = version_tuple = (2, 21, 1)
+__version__ = version = '2.22.1'
+__version_tuple__ = version_tuple = (2, 22, 1)
 
 __commit_id__ = commit_id = None

avrotize/avrotogo.py

@@ -10,8 +10,15 @@ JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 class AvroToGo:
     """Converts Avro schema to Go structs, including JSON and Avro marshalling methods"""
 
+    # 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.generated_types_avro_namespace: Dict[str, str] = {}
         self.generated_types_go_package: Dict[str, str] = {}
@@ -25,14 +32,15 @@ class AvroToGo:
         self.structs = []
         self.enums = []
 
+    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) -> 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:
+        if name in self.GO_RESERVED_WORDS:
             return f"{name}_"
         return name
 
@@ -157,6 +165,10 @@ class AvroToGo:
             'original_name': field['name']
         } for field in avro_schema.get('fields', [])]
 
+        # Collect imports from field types
+        go_types = [f['type'] for f in fields]
+        imports = self.get_imports_for_definition(go_types)
+
         context = {
             'doc': avro_schema.get('doc', ''),
             'struct_name': go_struct_name,
@@ -166,6 +178,7 @@ class AvroToGo:
             'avro_annotation': self.avro_annotation,
             'json_match_predicates': [self.get_is_json_match_clause(f['name'], f['type']) for f in fields],
             'base_package': self.base_package,
+            'imports': imports,
         }
 
         pkg_dir = os.path.join(self.output_dir, 'pkg', self.base_package)
@@ -430,7 +443,7 @@ class AvroToGo:
     def convert(self, avro_schema_path: str, output_dir: str):
         """Converts Avro schema to Go"""
         if not self.base_package:
-            self.base_package = os.path.splitext(os.path.basename(avro_schema_path))[0]
+            self.base_package = self._safe_package_name(os.path.splitext(os.path.basename(avro_schema_path))[0])
 
         with open(avro_schema_path, 'r', encoding='utf-8') as file:
             schema = json.load(file)

avrotize/avrotojava/class_test.java.jinja

@@ -113,8 +113,7 @@ public class {{ test_class_name }} {
             "Instances with different {{ field.field_name }} should not be equal");
         {%- elif field.is_enum %}
         // Enum - try to get a different enum value if more than one value exists
-        {%- set simple_type = base_type.split('.')[-1] if '.' in base_type else base_type %}
-        {{ simple_type }}[] enumValues = {{ simple_type }}.values();
+        {{ base_type }}[] enumValues = {{ base_type }}.values();
         if (enumValues.length > 1) {
             instance2.set{{ field.field_name | pascal }}(enumValues[(instance2.get{{ field.field_name | pascal }}().ordinal() + 1) % enumValues.length]);
             assertNotEquals(instance1, instance2, 
@@ -150,8 +149,7 @@ public class {{ test_class_name }} {
         {%- if '<' in field.field_type %}
         {{ field.field_type }} testValue = {{ field.test_value }};
         {%- else %}
-        {%- set simple_field_type = field.field_type.split('.')[-1] if '.' in field.field_type else field.field_type %}
-        {{ simple_field_type }} testValue = {{ field.test_value }};
+        {{ field.field_type }} testValue = {{ field.test_value }};
         {%- endif %}
         {%- if not field.is_const %}
         instance.set{{ field.field_name | pascal }}(testValue);

avrotize/avrotojava.py

@@ -1721,6 +1721,51 @@ class AvroToJava:
     def get_test_imports(self, fields: List) -> List[str]:
         """ Gets the necessary imports for the test class """
         imports = []
+        
+        # Track simple names to detect conflicts
+        # Map: simple_name -> list of FQNs that have that simple name
+        simple_name_to_fqns: Dict[str, List[str]] = {}
+        
+        # First pass: collect all custom type FQNs and their simple names
+        for field in fields:
+            inner_types = []
+            if field.field_type.startswith("List<"):
+                inner_type = field.field_type[5:-1]
+                if inner_type.startswith("Map<"):
+                    start = inner_type.index('<') + 1
+                    end = inner_type.rindex('>')
+                    map_types = inner_type[start:end].split(',')
+                    if len(map_types) > 1:
+                        inner_types.append(map_types[1].strip())
+                else:
+                    inner_types.append(inner_type)
+            elif field.field_type.startswith("Map<"):
+                start = field.field_type.index('<') + 1
+                end = field.field_type.rindex('>')
+                map_types = field.field_type[start:end].split(',')
+                if len(map_types) > 1:
+                    inner_types.append(map_types[1].strip())
+            if not field.field_type.startswith(("List<", "Map<")):
+                inner_types.append(field.field_type)
+            if hasattr(field, 'java_type_obj') and field.java_type_obj and field.java_type_obj.union_types:
+                for union_member_type in field.java_type_obj.union_types:
+                    inner_types.append(union_member_type.type_name)
+            
+            for type_to_check in inner_types:
+                if type_to_check in self.generated_types_java_package and '.' in type_to_check:
+                    simple_name = type_to_check.split('.')[-1]
+                    if simple_name not in simple_name_to_fqns:
+                        simple_name_to_fqns[simple_name] = []
+                    if type_to_check not in simple_name_to_fqns[simple_name]:
+                        simple_name_to_fqns[simple_name].append(type_to_check)
+        
+        # Find conflicting simple names (same simple name, different FQNs)
+        conflicting_fqns: set = set()
+        for simple_name, fqns in simple_name_to_fqns.items():
+            if len(fqns) > 1:
+                # This simple name has conflicts - mark all FQNs as conflicting
+                conflicting_fqns.update(fqns)
+        
         for field in fields:
             # Extract inner types from generic collections
             inner_types = []
@@ -1772,7 +1817,8 @@ class AvroToJava:
                 if type_to_check in self.generated_types_java_package:
                     type_kind = self.generated_types_java_package[type_to_check]
                     # Only import if it's a fully qualified name with a package
-                    if '.' in type_to_check:
+                    # Skip imports for types with conflicting simple names - they'll use FQN
+                    if '.' in type_to_check and type_to_check not in conflicting_fqns:
                         import_stmt = f"import {type_to_check};"
                         if import_stmt not in imports:
                             imports.append(import_stmt)
@@ -1809,10 +1855,11 @@ class AvroToJava:
                                     if java_qualified_name:
                                         if java_qualified_name in self.generated_types_java_package or java_qualified_name.split('.')[-1] in self.generated_types_java_package:
                                             member_type_kind = self.generated_types_java_package.get(java_qualified_name, self.generated_types_java_package.get(java_qualified_name.split('.')[-1], None))
-                                            # Import the class/enum
-                                            class_import = f"import {java_qualified_name};"
-                                            if class_import not in imports:
-                                                imports.append(class_import)
+                                            # Import the class/enum only if not conflicting
+                                            if java_qualified_name not in conflicting_fqns:
+                                                class_import = f"import {java_qualified_name};"
+                                                if class_import not in imports:
+                                                    imports.append(class_import)
                                             # No longer import test classes - we instantiate classes directly
         return imports
 
@@ -1920,6 +1967,21 @@ class AvroToJava:
             'Double': 'Double.valueOf(3.14)',
             'byte[]': 'new byte[] { 0x01, 0x02, 0x03 }',
             'Object': 'null',  # Use null for Object types (Avro unions) to avoid reference equality issues
+            # Java time types - use factory methods, not constructors
+            'Instant': 'java.time.Instant.now()',
+            'java.time.Instant': 'java.time.Instant.now()',
+            'LocalDate': 'java.time.LocalDate.now()',
+            'java.time.LocalDate': 'java.time.LocalDate.now()',
+            'LocalTime': 'java.time.LocalTime.now()',
+            'java.time.LocalTime': 'java.time.LocalTime.now()',
+            'LocalDateTime': 'java.time.LocalDateTime.now()',
+            'java.time.LocalDateTime': 'java.time.LocalDateTime.now()',
+            'Duration': 'java.time.Duration.ofSeconds(42)',
+            'java.time.Duration': 'java.time.Duration.ofSeconds(42)',
+            'UUID': 'java.util.UUID.randomUUID()',
+            'java.util.UUID': 'java.util.UUID.randomUUID()',
+            'BigDecimal': 'new java.math.BigDecimal("42.00")',
+            'java.math.BigDecimal': 'new java.math.BigDecimal("42.00")',
         }
         
         # Handle generic types

avrotize/avrotojsons.py

@@ -184,16 +184,38 @@ class AvroToJsonSchemaConverter:
     def handle_type_union(self, types: List[Union[str, Dict[str, Any]]]) -> Dict[str, Any] | List[Dict[str, Any]| str] | str:
         """
         Handle Avro type unions, returning a JSON schema that validates against any of the types.
+        Preserves nullability from Avro unions containing 'null'.
         """
+        is_nullable = 'null' in types
         non_null_types = [t for t in types if t != 'null']
+        
         if len(non_null_types) == 1:
-            # Single non-null type
-            return self.parse_avro_schema(non_null_types[0])
+            # Single non-null type - check if it's a primitive that can use type array
+            single_type = non_null_types[0]
+            json_schema = self.parse_avro_schema(single_type)
+            
+            if is_nullable and isinstance(json_schema, dict):
+                # For primitives with a simple 'type' field, we can use type array notation
+                if 'type' in json_schema and isinstance(json_schema['type'], str) and '$ref' not in json_schema:
+                    # Primitive type - add null to type array
+                    json_schema = copy.deepcopy(json_schema)
+                    json_schema['type'] = [json_schema['type'], 'null']
+                elif '$ref' in json_schema:
+                    # Reference type - use oneOf with null
+                    json_schema = {
+                        'oneOf': [
+                            {'type': 'null'},
+                            json_schema
+                        ]
+                    }
+            return json_schema
         else:
             # Multiple non-null types
-            union_types = [self.convert_reference(t) if isinstance(t,str) and t in self.defined_types else self.avro_primitive_to_json_type(t)
+            union_types = [self.convert_reference(t) if isinstance(t, str) and t in self.defined_types else self.avro_primitive_to_json_type(t)
                             if isinstance(t, str) else self.parse_avro_schema(t)
                                 for t in non_null_types]
+            if is_nullable:
+                union_types.insert(0, {'type': 'null'})
             return {
                 'oneOf': union_types
             }

avrotize/avrotopython/dataclass_core.jinja

@@ -25,7 +25,7 @@ import avro.schema
 import avro.name
 import avro.io
 {%- endif %}
-{%- for import_type in import_types if import_type not in ['datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta', 'decimal.Decimal'] %}
+{%- for import_type in import_types if import_type not in ['datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta', 'decimal.Decimal', 'uuid.UUID'] %}
 from {{ '.'.join(import_type.split('.')[:-1]) | lower }} import {{ import_type.split('.')[-1] }}
 {%- endfor %}
 {%- for import_type in import_types if import_type in ['datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta'] %}
@@ -33,6 +33,16 @@ from {{ '.'.join(import_type.split('.')[:-1]) | lower }} import {{ import_type.s
 import datetime
 {%- endif %}
 {%- endfor %}
+{%- for import_type in import_types if import_type == 'decimal.Decimal' %}
+{%- if loop.first %}
+import decimal
+{%- endif %}
+{%- endfor %}
+{%- for import_type in import_types if import_type == 'uuid.UUID' %}
+{%- if loop.first %}
+import uuid
+{%- endif %}
+{%- endfor %}
 
 {% if dataclasses_json_annotation %}
 @dataclass_json(undefined=Undefined.EXCLUDE)

avrotize/avrotopython.py

@@ -12,6 +12,38 @@ from avrotize.common import fullname, get_typing_args_from_string, is_generic_av
 
 INDENT = '    '
 
+# Python standard library modules that should not be shadowed by package names
+PYTHON_STDLIB_MODULES = {
+    'abc', 'aifc', 'argparse', 'array', 'ast', 'asynchat', 'asyncio', 'asyncore',
+    'atexit', 'audioop', 'base64', 'bdb', 'binascii', 'binhex', 'bisect', 'builtins',
+    'bz2', 'calendar', 'cgi', 'cgitb', 'chunk', 'cmath', 'cmd', 'code', 'codecs',
+    'codeop', 'collections', 'colorsys', 'compileall', 'concurrent', 'configparser',
+    'contextlib', 'contextvars', 'copy', 'copyreg', 'cProfile', 'crypt', 'csv',
+    'ctypes', 'curses', 'dataclasses', 'datetime', 'dbm', 'decimal', 'difflib',
+    'dis', 'distutils', 'doctest', 'email', 'encodings', 'enum', 'errno', 'faulthandler',
+    'fcntl', 'filecmp', 'fileinput', 'fnmatch', 'fractions', 'ftplib', 'functools',
+    'gc', 'getopt', 'getpass', 'gettext', 'glob', 'graphlib', 'grp', 'gzip',
+    'hashlib', 'heapq', 'hmac', 'html', 'http', 'imaplib', 'imghdr', 'imp',
+    'importlib', 'inspect', 'io', 'ipaddress', 'itertools', 'json', 'keyword',
+    'lib2to3', 'linecache', 'locale', 'logging', 'lzma', 'mailbox', 'mailcap',
+    'marshal', 'math', 'mimetypes', 'mmap', 'modulefinder', 'multiprocessing',
+    'netrc', 'nis', 'nntplib', 'numbers', 'operator', 'optparse', 'os', 'ossaudiodev',
+    'pathlib', 'pdb', 'pickle', 'pickletools', 'pipes', 'pkgutil', 'platform',
+    'plistlib', 'poplib', 'posix', 'posixpath', 'pprint', 'profile', 'pstats',
+    'pty', 'pwd', 'py_compile', 'pyclbr', 'pydoc', 'queue', 'quopri', 'random',
+    're', 'readline', 'reprlib', 'resource', 'rlcompleter', 'runpy', 'sched',
+    'secrets', 'select', 'selectors', 'shelve', 'shlex', 'shutil', 'signal',
+    'site', 'smtpd', 'smtplib', 'sndhdr', 'socket', 'socketserver', 'spwd',
+    'sqlite3', 'ssl', 'stat', 'statistics', 'string', 'stringprep', 'struct',
+    'subprocess', 'sunau', 'symtable', 'sys', 'sysconfig', 'syslog', 'tabnanny',
+    'tarfile', 'telnetlib', 'tempfile', 'termios', 'test', 'textwrap', 'threading',
+    'time', 'timeit', 'tkinter', 'token', 'tokenize', 'trace', 'traceback',
+    'tracemalloc', 'tty', 'turtle', 'turtledemo', 'types', 'typing', 'unicodedata',
+    'unittest', 'urllib', 'uu', 'uuid', 'venv', 'warnings', 'wave', 'weakref',
+    'webbrowser', 'winreg', 'winsound', 'wsgiref', 'xdrlib', 'xml', 'xmlrpc',
+    'zipapp', 'zipfile', 'zipimport', 'zlib', 'zoneinfo',
+}
+
 
 def is_python_reserved_word(word: str) -> bool:
     """Checks if a word is a Python reserved word"""
@@ -25,6 +57,13 @@ def is_python_reserved_word(word: str) -> bool:
     return word in reserved_words
 
 
+def safe_package_name(name: str) -> str:
+    """Converts a name to a safe Python package name that won't shadow stdlib"""
+    if name.lower() in PYTHON_STDLIB_MODULES:
+        return f"{name}_types"
+    return name
+
+
 class AvroToPython:
     """Converts Avro schema to Python data classes"""
 
@@ -167,6 +206,9 @@ class AvroToPython:
                 enum_ref = self.generate_enum(avro_type, parent_package, write_file=True)
                 import_types.add(enum_ref)
                 return self.strip_package_from_fully_qualified_name(enum_ref)
+            elif avro_type['type'] == 'fixed':
+                # Fixed types are represented as bytes in Python
+                return 'bytes'
             elif avro_type['type'] == 'array':
                 return f"typing.List[{self.convert_avro_type_to_python(avro_type['items'], parent_package, import_types)}]"
             elif avro_type['type'] == 'map':
@@ -611,6 +653,7 @@ def convert_avro_to_python(avro_schema_path, py_file_path, package_name='', data
     if not package_name:
         package_name = os.path.splitext(os.path.basename(avro_schema_path))[
             0].lower().replace('-', '_')
+    package_name = safe_package_name(package_name)
 
     avro_to_python = AvroToPython(
         package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
@@ -619,6 +662,7 @@ def convert_avro_to_python(avro_schema_path, py_file_path, package_name='', data
 
 def convert_avro_schema_to_python(avro_schema, py_file_path, package_name='', dataclasses_json_annotation=False, avro_annotation=False):
     """Converts Avro schema to Python data classes"""
+    package_name = safe_package_name(package_name) if package_name else package_name
     avro_to_python = AvroToPython(
         package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
     if isinstance(avro_schema, dict):

avrotize/avrotorust/dataclass_enum.rs.jinja

@@ -55,20 +55,22 @@ mod tests {
     use super::*;
     use rand::Rng;
 
+    {%- if serde_annotation %}
     #[test]
     fn test_serialize_deserialize_{{ enum_name.lower() }}() {
         {%- for symbol in symbols %}
         let instance = {{ enum_name }}::{{ symbol }};
-        {%- if serde_annotation %}
         let json_bytes = serde_json::to_vec(&instance).unwrap();
         let deserialized_instance: {{ enum_name }} = serde_json::from_slice(&json_bytes).unwrap();
         assert_eq!(instance, deserialized_instance);
-        {%- endif %}
-        {%- if avro_annotation %}
-        let avro_bytes = instance.to_byte_array("avro/binary").unwrap();
-        let deserialized_avro_instance: {{ enum_name }} = {{ enum_name }}::from_data(&avro_bytes, "avro/binary").unwrap();
-        assert_eq!(instance, deserialized_avro_instance);
-        {%- endif %}
+        {%- endfor %}
+    }
+    {%- endif %}
+
+    #[test]
+    fn test_enum_variants_{{ enum_name.lower() }}() {
+        {%- for symbol in symbols %}
+        let _instance = {{ enum_name }}::{{ symbol }};
         {%- endfor %}
     }
 }

avrotize/avrotorust/dataclass_struct.rs.jinja

@@ -4,28 +4,28 @@ use apache_avro::Schema;
 {%- endif %}
 {%- if serde_annotation or avro_annotation %}
 use serde::{Serialize, Deserialize};
-{%- endif %}
 use std::io::Write;
 use flate2::write::GzEncoder;
 use flate2::read::GzDecoder;
+{%- endif %}
 {%- set uses_chrono = false %}
 {%- set uses_uuid = false %}
 {%- set uses_hashmap = false%}
 {%- for field in fields %}
-{%- if field.type == "NaiveDate" or field.type == "NaiveTime" or field.type == "NaiveDateTime" %}
+{%- if field.type == "NaiveDate" or field.type == "NaiveTime" or field.type == "NaiveDateTime" or "chrono::" in field.type %}
 {%- set uses_chrono = true %}
 {%- endif %}
-{%- if field.type == "Uuid" %}
+{%- if field.type == "Uuid" or "uuid::" in field.type %}
 {%- set uses_uuid = true %}
 {%- endif %}
-{%- if field.type.startswith("HashMap<") %}
+{%- if field.type.startswith("HashMap<") or "HashMap<" in field.type %}
 {%- set uses_hashmap = true %}
 {%- endif %}
 {%- endfor %}
 {%- if uses_chrono %}
 use chrono::{NaiveDate, NaiveTime, NaiveDateTime};
 {%- endif %}
-{%- if uuid %}
+{%- if uses_uuid %}
 use uuid::Uuid;
 {%- endif %}
 {%- if uses_hashmap %}
@@ -39,7 +39,7 @@ use std::collections::HashMap;
 #[derive(Debug{%- if serde_annotation or avro_annotation %}, Serialize, Deserialize{%- endif %}, PartialEq, Clone, Default)]
 pub struct {{ struct_name }} {
 {%- for field in fields %}
-    {%- if field.serde_rename %}
+    {%- if field.serde_rename and (serde_annotation or avro_annotation) %}
     #[serde(rename = "{{ field.original_name }}")]
     {%- endif %}
     pub {{ field.name }}: {{ field.type }},
@@ -55,6 +55,7 @@ lazy_static! {
 {%- endif %}
 
 impl {{ struct_name }} {
+{%- if serde_annotation or avro_annotation %}
    /// Serializes the struct to a byte array based on the provided content type
     pub fn to_byte_array(&self, content_type: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
         let result: Vec<u8>;
@@ -70,14 +71,10 @@ impl {{ struct_name }} {
             let value = apache_avro::to_value(self).unwrap();
             result = apache_avro::to_avro_datum(&SCHEMA, value).unwrap();
         }
-        {%- endif %}
-        {%- if avro_annotation or serde_annotation %}
+        else {% endif -%}
         {
-        {%- endif %}
             return Err(format!("unsupported media type: {}", media_type).into())
-        {%- if avro_annotation or serde_annotation %}
         }
-        {%- endif %}
         if media_type.ends_with("+gzip") {
             let mut encoder = GzEncoder::new(Vec::new(), flate2::Compression::default());
             encoder.write_all(&result)?;
@@ -87,7 +84,9 @@ impl {{ struct_name }} {
             return Ok(result)
         }
     }
+{%- endif %}
 
+{%- if serde_annotation or avro_annotation %}
     /// Deserializes the struct from a byte array based on the provided content type
     pub fn from_data(data: impl AsRef<[u8]>, content_type: &str) -> Result<Self, Box<dyn std::error::Error>> {
         let media_type = content_type.split(';').next().unwrap_or("");
@@ -114,7 +113,9 @@ impl {{ struct_name }} {
         {%- endif %}
         Err(format!("unsupported media type: {}", media_type).into())
     }
+{%- endif %}
 
+{%- if serde_annotation or avro_annotation %}
     /// Checks if the given JSON value matches the schema of the struct
     pub fn is_json_match(node: &serde_json::Value) -> bool {
         {%- for predicate in json_match_predicates %}
@@ -122,6 +123,7 @@ impl {{ struct_name }} {
         {%- endfor %}
         true
     }
+{%- endif %}
 
     /// Returns the struct instance itself
     pub fn to_object(&self) -> &Self {
@@ -160,6 +162,12 @@ mod tests {
         assert!(instance.{{ field.name }} != {{ field_type }}::default()); // Check that {{ field.name }} is not default
         {%- elif field.type.startswith("std::collections::HashMap<")%}
         assert!(instance.{{ field.name }}.len() >= 0); // Check that {{ field.name }} is not empty
+        {%- elif field.is_generated_type %}
+        // Skip default comparison for generated types (enums/unions) as random values may match default
+        let _ = &instance.{{ field.name }};
+        {%- elif field.type in ["i8", "i16", "i32", "i64", "u8", "u16", "u32", "u64", "f32", "f64", "isize", "usize"] %}
+        // Skip default comparison for numeric types as random values can legitimately be 0
+        let _ = instance.{{ field.name }};
         {%- elif field.type != "bool" %}
         assert!(instance.{{ field.name }} != {{ field.type }}::default()); // Check that {{ field.name }} is not default
         {%- endif %}

avrotize/avrotorust/dataclass_union.rs.jinja

@@ -1,4 +1,4 @@
-{%- if serde_annotation %}
+{%- if serde_annotation or avro_annotation %}
 use serde::{self, Serialize, Deserialize};
 {%- endif %}
 
@@ -70,14 +70,25 @@ impl {{ union_enum_name }} {
 
 #[cfg(test)]
 impl {{ union_enum_name }} {
+{%- set unique_fields = union_fields | selectattr('is_first_with_predicate') | list %}
     pub fn generate_random_instance() -> {{ union_enum_name }} {
         let mut rng = rand::thread_rng();
+        {%- if serde_annotation and unique_fields | length < union_fields | length %}
+        // Only pick from variants with unique JSON structures to ensure round-trip works
+        match rand::Rng::gen_range(&mut rng, 0..{{ unique_fields | length }}) {
+            {%- for union_field in unique_fields %}
+            {{ loop.index0 }} => {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }}),
+            {%- endfor %}
+            _ => panic!("Invalid random index generated"),
+        }
+        {%- else %}
         match rand::Rng::gen_range(&mut rng, 0..{{ union_fields | length }}) {
             {%- for union_field in union_fields %}
             {{ loop.index0 }} => {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }}),
             {%- endfor %}
             _ => panic!("Invalid random index generated"),
         }
+        {%- endif %}
     }
 }
 
@@ -85,21 +96,28 @@ impl {{ union_enum_name }} {
 mod tests {
     use super::*;
 
+    {%- if serde_annotation %}
     #[test]
     fn test_serialize_deserialize_{{ union_enum_name.lower() }}() {
         let mut rng = rand::thread_rng();
         {%- for union_field in union_fields %}
+        {%- if union_field.is_first_with_predicate %}
         let instance = {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }});
-        {%- if serde_annotation %}
         let json_bytes = serde_json::to_vec(&instance).unwrap();
         let deserialized_instance: {{ union_enum_name }} = serde_json::from_slice(&json_bytes).unwrap();
         assert_eq!(instance, deserialized_instance);
+        {%- else %}
+        // Skip {{ union_field.name }} - structurally identical to earlier variant, would deserialize as first match
         {%- endif %}
-        {%- if avro_annotation %}
-        let avro_bytes = instance.to_byte_array("avro/binary").unwrap();
-        let deserialized_avro_instance: {{ union_enum_name }} = {{ union_enum_name }}::from_data(&avro_bytes, "avro/binary").unwrap();
-        assert_eq!(instance, deserialized_avro_instance);
-        {%- endif %}
+        {%- endfor %}
+    }
+    {%- endif %}
+
+    #[test]
+    fn test_union_variants_{{ union_enum_name.lower() }}() {
+        let mut rng = rand::thread_rng();
+        {%- for union_field in union_fields %}
+        let _instance = {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }});
         {%- endfor %}
     }
 }

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"""

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

avrotize/structuretopython.py

@@ -15,6 +15,38 @@ JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 
 INDENT = '    '
 
+# Python standard library modules that should not be shadowed by package names
+PYTHON_STDLIB_MODULES = {
+    'abc', 'aifc', 'argparse', 'array', 'ast', 'asynchat', 'asyncio', 'asyncore',
+    'atexit', 'audioop', 'base64', 'bdb', 'binascii', 'binhex', 'bisect', 'builtins',
+    'bz2', 'calendar', 'cgi', 'cgitb', 'chunk', 'cmath', 'cmd', 'code', 'codecs',
+    'codeop', 'collections', 'colorsys', 'compileall', 'concurrent', 'configparser',
+    'contextlib', 'contextvars', 'copy', 'copyreg', 'cProfile', 'crypt', 'csv',
+    'ctypes', 'curses', 'dataclasses', 'datetime', 'dbm', 'decimal', 'difflib',
+    'dis', 'distutils', 'doctest', 'email', 'encodings', 'enum', 'errno', 'faulthandler',
+    'fcntl', 'filecmp', 'fileinput', 'fnmatch', 'fractions', 'ftplib', 'functools',
+    'gc', 'getopt', 'getpass', 'gettext', 'glob', 'graphlib', 'grp', 'gzip',
+    'hashlib', 'heapq', 'hmac', 'html', 'http', 'imaplib', 'imghdr', 'imp',
+    'importlib', 'inspect', 'io', 'ipaddress', 'itertools', 'json', 'keyword',
+    'lib2to3', 'linecache', 'locale', 'logging', 'lzma', 'mailbox', 'mailcap',
+    'marshal', 'math', 'mimetypes', 'mmap', 'modulefinder', 'multiprocessing',
+    'netrc', 'nis', 'nntplib', 'numbers', 'operator', 'optparse', 'os', 'ossaudiodev',
+    'pathlib', 'pdb', 'pickle', 'pickletools', 'pipes', 'pkgutil', 'platform',
+    'plistlib', 'poplib', 'posix', 'posixpath', 'pprint', 'profile', 'pstats',
+    'pty', 'pwd', 'py_compile', 'pyclbr', 'pydoc', 'queue', 'quopri', 'random',
+    're', 'readline', 'reprlib', 'resource', 'rlcompleter', 'runpy', 'sched',
+    'secrets', 'select', 'selectors', 'shelve', 'shlex', 'shutil', 'signal',
+    'site', 'smtpd', 'smtplib', 'sndhdr', 'socket', 'socketserver', 'spwd',
+    'sqlite3', 'ssl', 'stat', 'statistics', 'string', 'stringprep', 'struct',
+    'subprocess', 'sunau', 'symtable', 'sys', 'sysconfig', 'syslog', 'tabnanny',
+    'tarfile', 'telnetlib', 'tempfile', 'termios', 'test', 'textwrap', 'threading',
+    'time', 'timeit', 'tkinter', 'token', 'tokenize', 'trace', 'traceback',
+    'tracemalloc', 'tty', 'turtle', 'turtledemo', 'types', 'typing', 'unicodedata',
+    'unittest', 'urllib', 'uu', 'uuid', 'venv', 'warnings', 'wave', 'weakref',
+    'webbrowser', 'winreg', 'winsound', 'wsgiref', 'xdrlib', 'xml', 'xmlrpc',
+    'zipapp', 'zipfile', 'zipimport', 'zlib', 'zoneinfo',
+}
+
 
 def is_python_reserved_word(word: str) -> bool:
     """Checks if a word is a Python reserved word"""
@@ -28,6 +60,13 @@ def is_python_reserved_word(word: str) -> bool:
     return word in reserved_words
 
 
+def safe_package_name(name: str) -> str:
+    """Converts a name to a safe Python package name that won't shadow stdlib"""
+    if name.lower() in PYTHON_STDLIB_MODULES:
+        return f"{name}_types"
+    return name
+
+
 class StructureToPython:
     """ Converts JSON Structure schema to Python classes """
 
@@ -110,11 +149,38 @@ class StructureToPython:
                type_name.startswith('typing.Optional[') or type_name.startswith('typing.Union[') or \
                type_name == 'typing.Any'
 
+    def safe_identifier(self, name: str, class_name: str = '', fallback_prefix: str = 'field') -> str:
+        """Converts a name to a safe Python identifier.
+        
+        Handles:
+        - Reserved words (append _)
+        - 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, but keep intentional ones
+        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_python_reserved_word(safe):
+            safe = safe + '_'
+        # Handle class name collision
+        if class_name and safe == class_name:
+            safe = safe + '_'
+        return safe
+
     def safe_name(self, name: str) -> str:
-        """Converts a name to a safe Python name"""
-        if is_python_reserved_word(name):
-            return name + "_"
-        return name
+        """Converts a name to a safe Python name (legacy wrapper)"""
+        return self.safe_identifier(name)
 
     def pascal_type_name(self, ref: str) -> str:
         """Converts a reference to a type name"""
@@ -324,7 +390,7 @@ class StructureToPython:
         # Generate field docstrings
         field_docstrings = [{
             'name': self.safe_name(field['name']),
-            'original_name': field['name'],
+            'original_name': field.get('json_name') or field['name'],
             'type': field['type'],
             'is_primitive': field['is_primitive'],
             'is_enum': field['is_enum'],
@@ -369,7 +435,10 @@ class StructureToPython:
     def generate_field(self, prop_name: str, prop_schema: Dict, class_name: str, 
                       parent_namespace: str, required_props: List, import_types: Set[str]) -> Dict:
         """ Generates a field for a Python dataclass """
-        field_name = prop_name
+        # 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
 
         # Check if this is a const field
         if 'const' in prop_schema:
@@ -378,6 +447,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,
                 'type': prop_type,
                 'is_primitive': self.is_python_primitive(prop_type) or self.is_python_typing_struct(prop_type),
                 'is_enum': False,
@@ -404,6 +474,7 @@ class StructureToPython:
 
         return {
             'name': field_name,
+            'json_name': prop_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',
@@ -786,6 +857,7 @@ def convert_structure_to_python(structure_schema_path, py_file_path, package_nam
         if base_name.endswith('.struct'):
             base_name = base_name[:-7]  # Remove '.struct' suffix
         package_name = base_name.lower().replace('-', '_')
+    package_name = safe_package_name(package_name)
 
     structure_to_python = StructureToPython(package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
     structure_to_python.convert(structure_schema_path, py_file_path)
@@ -793,6 +865,7 @@ def convert_structure_to_python(structure_schema_path, py_file_path, package_nam
 
 def convert_structure_schema_to_python(structure_schema, py_file_path, package_name='', dataclasses_json_annotation=False):
     """Converts JSON Structure schema to Python dataclasses"""
+    package_name = safe_package_name(package_name) if package_name else package_name
     structure_to_python = StructureToPython(package_name, dataclasses_json_annotation=dataclasses_json_annotation)
     if isinstance(structure_schema, dict):
         structure_schema = [structure_schema]

avrotize/structuretots.py

@@ -329,7 +329,7 @@ class StructureToTypeScript:
         fields = []
         for prop_name, prop_schema in properties.items():
             field_type = self.convert_structure_type_to_typescript(
-                class_name, prop_name, prop_schema, namespace, import_types)
+                class_name, prop_name, prop_schema, schema_namespace, import_types)
             is_required = prop_name in required_props
             is_optional = not is_required
             field_type_no_null = self.strip_nullable(field_type)
@@ -479,6 +479,7 @@ class StructureToTypeScript:
         """ Generates a TypeScript tuple type from JSON Structure tuple type """
         tuple_name = pascal(explicit_name if explicit_name else structure_schema.get('name', 'Tuple'))
         namespace = self.concat_namespace(self.base_package, structure_schema.get('namespace', parent_namespace)).lower()
+        schema_namespace = structure_schema.get('namespace', parent_namespace)
         typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(parent_namespace, tuple_name)
         
         if typescript_qualified_name in self.generated_types:
@@ -489,7 +490,7 @@ class StructureToTypeScript:
         item_types = []
         for idx, item in enumerate(tuple_items):
             item_type = self.convert_structure_type_to_typescript(
-                tuple_name, f'item{idx}', item, namespace, import_types)
+                tuple_name, f'item{idx}', item, schema_namespace, import_types)
             item_types.append(item_type)
 
         # TypeScript tuples are just arrays with fixed length and types
@@ -737,4 +738,4 @@ def convert_structure_schema_to_typescript(structure_schema: JsonNode, output_di
         avro_annotation: Whether to include Avro annotations
     """
     converter = StructureToTypeScript(package_name, typedjson_annotation, avro_annotation)
-    converter.convert_schema(structure_schema, output_dir, package_name)
+    converter.convert_schema(structure_schema, output_dir, package_name)

{avrotize-2.21.1.dist-info → avrotize-2.22.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrotize
-Version: 2.21.1
+Version: 2.22.1
 Summary: Tools to convert from and to Avro Schema from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Requires-Python: >=3.10

{avrotize-2.21.1.dist-info → avrotize-2.22.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 avrotize/__init__.py,sha256=t5h5wkHXr6M0mmHAB5rhjZ3Gxy9xutGTGIfojfao9rI,3820
 avrotize/__main__.py,sha256=5pY8dYAURcOnFRvgb6fgaOIa_SOzPLIWbU8-ZTQ0jG4,88
-avrotize/_version.py,sha256=w0GJbqvrBbKA0xDzzXqfmy-zKEDei_ytc0ogfb890d8,706
+avrotize/_version.py,sha256=2Rc4v0v4QLr2kVq6V3tQOneBqZW00NrqxdxCLKrfD00,706
 avrotize/asn1toavro.py,sha256=QDNwfBfXMxSH-k487CA3CaGCGDzOLs4PpVbbENm5uF0,8386
 avrotize/avrotize.py,sha256=VHFpBltMVBpyt0ju3ZWW725BKjQ4Fk-nrAy8udW-X44,5713
 avrotize/avrotocpp.py,sha256=hRZV247_TDD7Sm6_8sFx-UH5SueLLx2Wg6TvAVUX0iE,25693
@@ -8,20 +8,20 @@ avrotize/avrotocsharp.py,sha256=k-tBex_vT-79yKZNetP9pKF63206NlT7KKBIXies9Cg,7140
 avrotize/avrotocsv.py,sha256=PaDEW2aGRFVNLwewWhJ3OwxbKFI3PBg_mTgtT4uLMko,3689
 avrotize/avrotodatapackage.py,sha256=zSCphLvCYiBKRAUCdccsr-4JysH3PyAS6fSgwa65Tss,7259
 avrotize/avrotodb.py,sha256=5fNJgz00VMimyOl7eI0lIxlcaN_JnN0mb2Q9lzCRecw,46989
-avrotize/avrotogo.py,sha256=RnycgAuGejq00hDdsUGdMHiJX6nr0VAqNArbCkTzUMg,21880
+avrotize/avrotogo.py,sha256=H4jxdO7laRWKJuU6mytz2sgUa_20hZUlsBrUGrCe_UU,22405
 avrotize/avrotographql.py,sha256=i6G7xWjH_Lsn_CLiM4BCPb8OyZuCCpsYjXwXNTRMwEE,7394
 avrotize/avrotoiceberg.py,sha256=plVHGWkED1YDLcMDxL7NMdJl2f8G32hwlNWFrBLcsD8,9057
-avrotize/avrotojava.py,sha256=_G_67xi1H0Ctj9KagiCnVNETvyPicOYO8ASvz6e1XYE,131861
+avrotize/avrotojava.py,sha256=NZZ7mUFVzvp7HBsU0XPiCwl4GVXE1RtS86pfNFJsIq8,135427
 avrotize/avrotojs.py,sha256=QjB6XjFnDrpZBZrrWqS0TN8fQfRXBfhHabfG73FOIo8,12249
-avrotize/avrotojsons.py,sha256=WXWniQqwcl8eU35VibDv7qJJwbiLV_yoWZ4JxiZ8mHA,21588
+avrotize/avrotojsons.py,sha256=I7EJz_IaCYLNzcycYXDOLAexHRHQfyb4yoWcxJ02vb0,22697
 avrotize/avrotojstruct.py,sha256=-Hs4Ta958bRKmOfSTzRFENABCZ6lQPSPbIBEXvOQD1M,14660
 avrotize/avrotokusto.py,sha256=D6AiRPa5uiZbqo9dqrFvAknsF5oNXgIzk8_08uZTZ2M,17636
 avrotize/avrotomd.py,sha256=WHPHnfmkI3xDNIHKZ3ReYxj6tib1eCny3JOznNSN6r8,5348
 avrotize/avrotools.py,sha256=dTbGgWQyKdSuvCf4yuoymwhYO5gX9ywPu-klIXYwKZM,6052
 avrotize/avrotoparquet.py,sha256=qm5hfia5elW1Yn4KACG8bbudLAqQSwGk3fIkTvdT5Rg,9088
 avrotize/avrotoproto.py,sha256=STqbdGjVrgKrlKXt-6dZlekW_Oq0W0StRx80St1XqIc,22486
-avrotize/avrotopython.py,sha256=K1r6STp9OJJfQOwVMVpKUKRdYuo89JHmp_wLIO4d0WE,31331
-avrotize/avrotorust.py,sha256=QMIBNkFpDlH44kuQo24k5D-f0lmdhoA5b7hEbhKsnMw,22214
+avrotize/avrotopython.py,sha256=7s73rKyaQDu5-uLnF4mK7Jat9F4jipQ-lLapPXg6aPI,34168
+avrotize/avrotorust.py,sha256=HEcDirRBCbXQNNs_FmkT-sp1dWQgZ8A23qkQYUxVuXE,24255
 avrotize/avrotots.py,sha256=u_XLjlHN0Gof5QYlpqK4X9WoX9rL30TjQMPg4TiyYnI,33241
 avrotize/avrotoxsd.py,sha256=iGQq_8kC0kfKsqvqS6s_mO-kJ8N5G8vXOwqRI_DZUxc,17744
 avrotize/cddltostructure.py,sha256=MA2c-P3CIEAxEaBX-FF299gR55xcLEV3FrfTr2QfayM,74491
@@ -44,22 +44,22 @@ avrotize/proto3parser.py,sha256=MfE84c-oAWWuzYmKlEZ5g5LUF7YzZaASFh2trX3UCaw,1560
 avrotize/prototoavro.py,sha256=hqXBGRxYojaEbEgoHZxXwMG4R1nWC7UMl_XNLWfqH38,17346
 avrotize/structuretocddl.py,sha256=RK_dTJf0oAo6BIBM48NHRcWC96OtUjlgUC6HzXs5Lkk,21234
 avrotize/structuretocpp.py,sha256=tBWOvyZPYQ1CHN6RgDnWlmzJ1giOyQ9SlHBHWvhPyiw,35898
-avrotize/structuretocsharp.py,sha256=qYYAV6M8I2xv-VUzOobPT1_FYAoBBe0VRTMe9eY8r1g,122229
+avrotize/structuretocsharp.py,sha256=Hi6C2HAIB3DxKZ4s8Q2_rK9QOqI_cLmObLkpwI3iO1o,123681
 avrotize/structuretocsv.py,sha256=w9cwXAnnakKaeTtXsLWWO8KwYnXUxyXvC7a-ZKs-E94,13851
 avrotize/structuretodatapackage.py,sha256=NEHRt30KfVDWH1EQakvuMdRZTtfVXx8fsaYud0ofb2g,29768
-avrotize/structuretodb.py,sha256=3QE_TCdNklGH5ymzGsEnX1sI4OhvX2AYKPH7xtR5tHk,43926
-avrotize/structuretogo.py,sha256=FNL5et5xxAoS0YSPJWGliWAFZPH_p8Nmu9pSEAT4J0U,32876
+avrotize/structuretodb.py,sha256=uk4hKSRNw1JwOsWSZGECjSwvmTFUipRvMgTGlKnviCo,44860
+avrotize/structuretogo.py,sha256=EtU7C5IqKzPrYaxKUQJMDMpk-rlc8eRwFzHe489jHp4,34100
 avrotize/structuretographql.py,sha256=wcGXnrup5v5saRa1BhR6o-X8q8ujsQMVqrFHQTBPjww,20468
 avrotize/structuretoiceberg.py,sha256=itKb33Kj-7-udk4eHTLmTEasIeh1ggpZ3e_bwCxLABM,15344
-avrotize/structuretojava.py,sha256=nlXRMfLcAEzGg3Q379UdQ6i9W7eqPjMFXFrN5d09r1E,46955
+avrotize/structuretojava.py,sha256=r6YfI-_HtdeGqotL5W31WR5sz-TE1VLdDegctpjeiC4,47886
 avrotize/structuretojs.py,sha256=TJuhUGqn0F2omjPVcrPeFPHY2KynRceFg9gMGvEenxA,29608
 avrotize/structuretojsons.py,sha256=PJrQBaf6yQHu5eFkePxbjPBEmL-fYfX2wj6OmH1jsWw,22495
 avrotize/structuretokusto.py,sha256=rOKgYIcm7ZK8RS-VvMFPNzPzwtv7c4dIKU-fKjrJLyM,30618
 avrotize/structuretomd.py,sha256=exfCldYbieVdduhotSoLrxsbphmyJQyeQso9qv4qyUw,13642
 avrotize/structuretoproto.py,sha256=Aq0-fwMXSjjAxgZ5mq1kpo_TauigMRrJK9LNyoN-YGs,42679
-avrotize/structuretopython.py,sha256=2dCa33nZBXgh996p3zA9uF3S1LHbOcpMSuoDXQPjAnw,39627
+avrotize/structuretopython.py,sha256=d9EZVDHq7r-x0ZYZIRYfCP6kub7MkEROuvzjTJfNVv0,43958
 avrotize/structuretorust.py,sha256=ChRmO7uzU-pMdDdS0Vtg-MVUaOaNhNUPwH-ZKKOHglU,35134
-avrotize/structuretots.py,sha256=W552IJbTetZuTKtFE5A8B75neyRJXP7Q3ioWZCunLtE,35182
+avrotize/structuretots.py,sha256=7jKoMOWwSJG_T_uZuEcPu-4d0dMuydAHvUhE86QSEJU,35274
 avrotize/structuretoxsd.py,sha256=01VpasyWSMOx04sILHLP7H-WkhGdXAEGKohUUfgrNf0,32797
 avrotize/xsdtoavro.py,sha256=nQtNH_3pEZBp67oUCPqzhvItEExHTe-8obsIfNRXt8Y,19064
 avrotize/avrotocpp/CMakeLists.txt.jinja,sha256=t2ADvvi3o20xfVrsRBaUvZlpVCDR4h6Szsf0GcuSkH0,3015
@@ -81,18 +81,18 @@ avrotize/avrotogo/go_helpers.jinja,sha256=WSjLIqkrYLUKdQBejEpOnNiENCaU8HQvm4gshy
 avrotize/avrotogo/go_struct.jinja,sha256=vI-xGVC1O7uAFYoY0T0kbT2Be5gFDkgc_UdFUbbpHZk,4272
 avrotize/avrotogo/go_test.jinja,sha256=r1tGQqHP5MiSRj3yQhPSQLNSx1ihfsl6MnUU7xbHAgM,1206
 avrotize/avrotogo/go_union.jinja,sha256=OcRVPWI-1OvYthh7cB-8RMT9nJEOStAQMfbW3b5hpUU,890
-avrotize/avrotojava/class_test.java.jinja,sha256=LvSZLumEBDZWHlXCbaJNlSb-ALILS2s9byIdGc7WHDM,9443
+avrotize/avrotojava/class_test.java.jinja,sha256=H950i6RlEoOoJadgUbEWOaeLIR3M9NHEF_hm4wFwbJs,9225
 avrotize/avrotojava/enum_test.java.jinja,sha256=INIKtiKrZwSFXVXgv8ouvzGv8vzjWouRq3DAPqxRs8k,545
 avrotize/avrotojava/testproject.pom.jinja,sha256=qRKGs9cCfex0hNgryyIJLae-pSpP4LMpPYcn8H8bBvk,2072
 avrotize/avrotomd/README.md.jinja,sha256=efG9ly41AjNMuOOnq9U7LXEhGylfHhVTzqe_COM4cRM,999
-avrotize/avrotopython/dataclass_core.jinja,sha256=eoKjpaFCspI-uqT6TZwzOh7UopbUd4kbGlJLJCKo_64,10336
+avrotize/avrotopython/dataclass_core.jinja,sha256=hvLtsN67dlPDmTIHScrUE0X1z3KxKMDPmIg80ziKCAk,10616
 avrotize/avrotopython/enum_core.jinja,sha256=QP5FDkMg5Si6xSHCr6L-nMe_94RH2mJdcAmFJH69BiY,2779
 avrotize/avrotopython/pyproject_toml.jinja,sha256=fEtJrk4pTrHCcvwpGf1KYoORA90HeJZdmeusx_WVAeo,462
 avrotize/avrotopython/test_class.jinja,sha256=h_8pyvrTRa9DTRzUP5tjnzXF4bMjbovqjNqDdx1CZYM,3203
 avrotize/avrotopython/test_enum.jinja,sha256=PeVxzC-gV5bizVnRs58RPoUDbXGI696B-VO4g-qB2lc,528
-avrotize/avrotorust/dataclass_enum.rs.jinja,sha256=-1-73XnG1k1eONMq7_aENVpoHOsMnj55CyjU3PT8M7U,2232
-avrotize/avrotorust/dataclass_struct.rs.jinja,sha256=AXFqCCW8fVdJXnSYTfpwKQeGG9JH8Goc3g1ILKEU-mE,7853
-avrotize/avrotorust/dataclass_union.rs.jinja,sha256=HuDKlM03hOkVx9Lm5p93IzQfUCokHz8wOu9iyEkwkUk,3801
+avrotize/avrotorust/dataclass_enum.rs.jinja,sha256=g4aYp0a7Yk8jO6aIiTXU8Obm48Qv63zxbzGREsWBBK8,2102
+avrotize/avrotorust/dataclass_struct.rs.jinja,sha256=_FAKZG9VSRhn5enJScH8Y3t5KJ0aXTRqzGbMTjO6-dk,8463
+avrotize/avrotorust/dataclass_union.rs.jinja,sha256=Ye4zVqpHgFNMUuvULCqN1aCWqezbWHppF_N_0hU0W2U,4640
 avrotize/avrotots/class_core.ts.jinja,sha256=KEKSXsjPVTXP_LTOIUVjsTWfT3g1ZVSrGjy0UMkEj0g,5081
 avrotize/avrotots/class_test.ts.jinja,sha256=zm3wXaSJ225y7knLj6I9zjrkPTEROLHYmBr8eDo7pCo,2752
 avrotize/avrotots/enum_core.ts.jinja,sha256=6NN_nF2y9us2saM7Wag8IN73BdIF0vxhPxq83NQEnm8,1522
@@ -139,7 +139,7 @@ avrotize/structuretojava/choice_core.jinja,sha256=H-VhQzIIwgu9myuw3j9WxFx01maTOl
 avrotize/structuretojava/class_core.jinja,sha256=mn3KVnvIxHIUB1Tep_YeISnM7k6ytQdOynQ4sUGrCAc,981
 avrotize/structuretojava/enum_core.jinja,sha256=yXnXQbr3IEudUj5OOFqDUJT7TfGqAJMy6O6K5DQ1lUQ,487
 avrotize/structuretojava/equals_hashcode.jinja,sha256=m_6EBJdRfQWnP8dmEJ2vkosyFaNkVyYDtyb9RKQCZtQ,946
-avrotize/structuretojava/pom.xml.jinja,sha256=0Je9fnd0Gb1RSPoD_chu3fafIu8SnRPuCKCw0mPXOTc,1089
+avrotize/structuretojava/pom.xml.jinja,sha256=DxGdDXa3XgdD5vMp498Fzf-nSEX3Fx4grKG09-g32Bg,1305
 avrotize/structuretojava/tuple_core.jinja,sha256=IZl3s_olYhwasA21uFqSZCyq4tLZ_jtQVD6ZQgUKmkk,1731
 avrotize/structuretojs/class_core.js.jinja,sha256=-DiN6dHxiEAc3bWCV6EAH1TpEdO2Fhs6d3tgYzxdLM4,779
 avrotize/structuretojs/enum_core.js.jinja,sha256=iMDePiuj4d7s7VuUOv3MnkFLKV9XBzReMR4TudZ3MbQ,205
@@ -148,7 +148,7 @@ avrotize/structuretojs/test_class.js.jinja,sha256=XTQEtuFRgQb0ixrA_E9uK3tM4OJCf3
 avrotize/structuretojs/test_enum.js.jinja,sha256=5vGrqUigmSFx_wFQQD-nE7P6o_HAyZEnmWpW0ScAkfw,1393
 avrotize/structuretojs/test_runner.js.jinja,sha256=RH-wqqBTVjiFzp0k5id5vtMGVllHTQbihnRRgsM5C7k,1185
 avrotize/structuretomd/README.md.jinja,sha256=UBBkspRnVI9E3RLRWPbxKSvoU9y4tKi1iqzn2iGJbDQ,4824
-avrotize/structuretopython/dataclass_core.jinja,sha256=Lw29JKHOTrLJNe8tr3RO16skBZF8vtC5edpOYsFjsck,15758
+avrotize/structuretopython/dataclass_core.jinja,sha256=fNcGjBx4rgJZQ1rNqoJ5npWZwr8j75R61W3-kSskJqk,15793
 avrotize/structuretopython/enum_core.jinja,sha256=DDE7Mw9M2hjb0x1ErY9IvwASgAkI1hzFWjKbHsTfDRs,1253
 avrotize/structuretopython/map_alias.jinja,sha256=lq1vh37yrMTlOKQXhcu5xxkZg8kCDnskw1DUqW06aq0,567
 avrotize/structuretopython/pyproject_toml.jinja,sha256=IuMr-XjXVmTx1R91DGLJ6y3LskCBcwt-xxJNi5hR1qA,587
@@ -164,8 +164,8 @@ avrotize/structuretots/index.ts.jinja,sha256=-R4R_En1N4W_BEN3z3bLts9Xi4KnBTDLrYM
 avrotize/structuretots/package.json.jinja,sha256=OfJn4g68VhBP-yvJCdsWm_1RHx1kphsmdWpxu_Fst1E,819
 avrotize/structuretots/test_class.ts.jinja,sha256=7tJ6hPo3A9zToTkwolVyXYhmZ_E4uI_OnnYsUUzUEdQ,1180
 avrotize/structuretots/tsconfig.json.jinja,sha256=8Pl65JW8uOMEexxkteobo0ZEqsJBO31HegNRUrf8XGQ,515
-avrotize-2.21.1.dist-info/entry_points.txt,sha256=m8J2TWiqbZh7SBQezc1CNrM_GVPWf01zOFcAKhzCC0U,51
-avrotize-2.21.1.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
-avrotize-2.21.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-avrotize-2.21.1.dist-info/METADATA,sha256=dtpNJWaoSiOH1ewSwtHKL4IHMhoQ5bWVHLSAmjiJj2U,80208
-avrotize-2.21.1.dist-info/RECORD,,
+avrotize-2.22.1.dist-info/entry_points.txt,sha256=m8J2TWiqbZh7SBQezc1CNrM_GVPWf01zOFcAKhzCC0U,51
+avrotize-2.22.1.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
+avrotize-2.22.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+avrotize-2.22.1.dist-info/METADATA,sha256=VlqM6wO1RE7NuEFnJMM2Gcdy3ZCJRVt1jhw6Um3pzig,80208
+avrotize-2.22.1.dist-info/RECORD,,