structurize 2.21.0__tar.gz → 2.22.0__tar.gz

{structurize-2.21.0/structurize.egg-info → structurize-2.22.0}/PKG-INFO

@@ -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 → structurize-2.22.0}/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'

{structurize-2.21.0 → structurize-2.22.0}/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)

{structurize-2.21.0 → structurize-2.22.0}/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

{structurize-2.21.0 → structurize-2.22.0}/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):

{structurize-2.21.0 → structurize-2.22.0}/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]

{structurize-2.21.0 → structurize-2.22.0}/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

{structurize-2.21.0 → structurize-2.22.0}/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"]

{structurize-2.21.0 → structurize-2.22.0}/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)