structurize 2.21.0__py3-none-any.whl → 2.22.0__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.0'
-__version_tuple__ = version_tuple = (2, 21, 0)
+__version__ = version = '2.22.0'
+__version_tuple__ = version_tuple = (2, 22, 0)
 
-__commit_id__ = commit_id = 'g1df522119'
+__commit_id__ = commit_id = 'g5d3e04df0'

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.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/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':
@@ -327,7 +369,8 @@ class AvroToPython:
     def generate_test_class(self, package_name: str, class_name: str, fields: List[Dict[str, str]], import_types: Set[str]) -> None:
         """Generates a unit test class for a Python data class"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_"+package_name.replace('.', '_').lower()
+        flat_package = package_name.replace('.', '_').lower()
+        tests_package_name = flat_package if flat_package.startswith('test_') else f"test_{flat_package}"
         test_class_definition = process_template(
             "avrotopython/test_class.jinja",
             package_name=package_name,
@@ -348,7 +391,8 @@ class AvroToPython:
     def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_"+package_name.replace('.', '_').lower()
+        flat_package = package_name.replace('.', '_').lower()
+        tests_package_name = flat_package if flat_package.startswith('test_') else f"test_{flat_package}"
         test_class_definition = process_template(
             "avrotopython/test_enum.jinja",
             package_name=package_name,
@@ -609,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)
@@ -617,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.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.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.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"""
@@ -286,6 +352,7 @@ class StructureToPython:
         class_name = pascal(explicit_name if explicit_name else structure_schema.get('name', 'UnnamedClass'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -323,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'],
@@ -358,8 +425,8 @@ class StructureToPython:
         )
 
         if write_file:
-            self.write_to_file(namespace, class_name, class_definition)
-            self.generate_test_class(namespace, class_name, field_docstrings, import_types)
+            self.write_to_file(package_name, class_name, class_definition)
+            self.generate_test_class(package_name, class_name, field_docstrings, import_types)
 
         self.generated_types[python_qualified_name] = 'class'
         self.generated_structure_types[python_qualified_name] = structure_schema
@@ -368,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:
@@ -377,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,
@@ -403,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',
@@ -424,6 +496,7 @@ class StructureToPython:
         class_name = pascal(structure_schema.get('name', field_name + 'Enum'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -442,8 +515,8 @@ class StructureToPython:
         )
 
         if write_file:
-            self.write_to_file(namespace, class_name, enum_definition)
-            self.generate_test_enum(namespace, class_name, symbols)
+            self.write_to_file(package_name, class_name, enum_definition)
+            self.generate_test_enum(package_name, class_name, symbols)
 
         self.generated_types[python_qualified_name] = 'enum'
         self.generated_enum_symbols[python_qualified_name] = symbols
@@ -513,6 +586,7 @@ class StructureToPython:
         class_name = pascal(structure_schema.get('name', 'UnnamedMap'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -537,7 +611,7 @@ class StructureToPython:
         )
         
         if write_file:
-            self.write_to_file(namespace, class_name, map_definition)
+            self.write_to_file(package_name, class_name, map_definition)
         
         self.generated_types[python_qualified_name] = 'map'
         return python_qualified_name
@@ -623,7 +697,8 @@ class StructureToPython:
                            import_types: Set[str]) -> None:
         """Generates a unit test class for a Python dataclass"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_" + package_name.replace('.', '_').lower()
+        # Use a simpler file naming scheme based on class name only
+        test_file_name = f"test_{class_name.lower()}"
         test_class_definition = process_template(
             "structuretopython/test_class.jinja",
             package_name=package_name,
@@ -636,7 +711,7 @@ class StructureToPython:
         )
 
         base_dir = os.path.join(self.output_dir, "tests")
-        test_file_path = os.path.join(base_dir, f"{tests_package_name.replace('.', '_').lower()}.py")
+        test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
         if not os.path.exists(os.path.dirname(test_file_path)):
             os.makedirs(os.path.dirname(test_file_path), exist_ok=True)
         with open(test_file_path, 'w', encoding='utf-8') as file:
@@ -645,7 +720,8 @@ class StructureToPython:
     def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_" + package_name.replace('.', '_').lower()
+        # Use a simpler file naming scheme based on class name only
+        test_file_name = f"test_{class_name.lower()}"
         test_class_definition = process_template(
             "structuretopython/test_enum.jinja",
             package_name=package_name,
@@ -654,7 +730,7 @@ class StructureToPython:
             symbols=symbols
         )
         base_dir = os.path.join(self.output_dir, "tests")
-        test_file_path = os.path.join(base_dir, f"{tests_package_name.replace('.', '_').lower()}.py")
+        test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
         if not os.path.exists(os.path.dirname(test_file_path)):
             os.makedirs(os.path.dirname(test_file_path), exist_ok=True)
         with open(test_file_path, 'w', encoding='utf-8') as file:
@@ -662,9 +738,8 @@ class StructureToPython:
 
     def write_to_file(self, package: str, class_name: str, python_code: str):
         """Writes a Python class to a file"""
-        # Add 'struct' module to the package path
-        full_package = f"{package}.struct"
-        parent_package_name = '.'.join(full_package.split('.')[:-1])
+        # The containing directory is the parent package (matches avrotopython.py)
+        parent_package_name = '.'.join(package.split('.')[:-1])
         parent_package_path = os.sep.join(parent_package_name.split('.')).lower()
         directory_path = os.path.join(self.output_dir, "src", parent_package_path)
         if not os.path.exists(directory_path):
@@ -777,7 +852,12 @@ class StructureToPython:
 def convert_structure_to_python(structure_schema_path, py_file_path, package_name='', dataclasses_json_annotation=False, avro_annotation=False):
     """Converts JSON Structure schema to Python dataclasses"""
     if not package_name:
-        package_name = os.path.splitext(os.path.basename(structure_schema_path))[0].lower().replace('-', '_')
+        # Strip .json extension, then also strip .struct suffix if present (*.struct.json naming convention)
+        base_name = os.path.splitext(os.path.basename(structure_schema_path))[0]
+        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)
@@ -785,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)
@@ -400,8 +400,10 @@ class StructureToTypeScript:
                      write_file: bool = True) -> str:
         """ Generates a TypeScript enum from JSON Structure enum """
         enum_name = pascal(structure_schema.get('name', field_name + 'Enum'))
-        namespace = self.concat_namespace(self.base_package, structure_schema.get('namespace', parent_namespace)).lower()
-        typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(parent_namespace, enum_name)
+        schema_namespace = structure_schema.get('namespace', parent_namespace)
+        namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        # Use schema_namespace (not parent_namespace) to match the file location
+        typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(schema_namespace, enum_name)
         
         if typescript_qualified_name in self.generated_types:
             return typescript_qualified_name
@@ -477,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:
@@ -487,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
@@ -735,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)

{structurize-2.21.0.dist-info → structurize-2.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 2.21.0
+Version: 2.22.0
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3

{structurize-2.21.0.dist-info → structurize-2.22.0.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=7_KqD5_cXvr3HDqW5pEAs09pUzYRm7mXb7a_T-0WYsA,714
+avrotize/_version.py,sha256=RizwlnbP9gT9Cli8S3AsqYTckMr4Y8rczsBdG4bV938,714
 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,10 +8,10 @@ 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/avrotojstruct.py,sha256=-Hs4Ta958bRKmOfSTzRFENABCZ6lQPSPbIBEXvOQD1M,14660
@@ -20,8 +20,8 @@ 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=sPsSLseSq-toKHnsFsYRRtGePGYospRz2mwGLep-POw,31147
-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,29 +44,29 @@ 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=jG2Vcf1KdezWrZo5lsecxLnmnMw1rA96uOxVWJQ4Rso,43372
+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=Ub7gRtsMXGmWVN1qbBiHuYXa9Qo2CqsVQKrg9vpX7h4,39073
+avrotize/structuretopython.py,sha256=d9EZVDHq7r-x0ZYZIRYfCP6kub7MkEROuvzjTJfNVv0,43958
 avrotize/structuretorust.py,sha256=ChRmO7uzU-pMdDdS0Vtg-MVUaOaNhNUPwH-ZKKOHglU,35134
-avrotize/structuretots.py,sha256=CcxY2EYf4QOG9-yC8TxStBWpk-QdhXKzL1zNHjVOBbw,35057
+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/dependencies/cpp/vcpkg/vcpkg.json,sha256=se5qnUVQ1Q6wN_DqgIioqKg_y7ouh9oly2iBAJJXkgw,414
 avrotize/dependencies/typescript/node22/package.json,sha256=oAW_2X-b715kV7aajwuONZEMkyQUJGviG3GwnoUa7hU,387
-structurize-2.21.0.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
-structurize-2.21.0.dist-info/METADATA,sha256=2MJw8QgOHf4vbwkCVYdGIPWhy4gsauA8WbUuipJMR5c,3670
-structurize-2.21.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-structurize-2.21.0.dist-info/entry_points.txt,sha256=biIH7jA5auhVqfbwHVk2gmD_gvrPYKgjpCAn0JWZ-Rs,55
-structurize-2.21.0.dist-info/top_level.txt,sha256=yn-yQ0Cm1O9fbF8KJgv4IIvX4YRGelKgPqZF1wS5P50,9
-structurize-2.21.0.dist-info/RECORD,,
+structurize-2.22.0.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
+structurize-2.22.0.dist-info/METADATA,sha256=nWSfeORdr2Q5aH2WjWQxw5-HcdXVAbGl7xmKrewxZNs,3670
+structurize-2.22.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+structurize-2.22.0.dist-info/entry_points.txt,sha256=biIH7jA5auhVqfbwHVk2gmD_gvrPYKgjpCAn0JWZ-Rs,55
+structurize-2.22.0.dist-info/top_level.txt,sha256=yn-yQ0Cm1O9fbF8KJgv4IIvX4YRGelKgPqZF1wS5P50,9
+structurize-2.22.0.dist-info/RECORD,,