structurize 3.7.0__tar.gz → 3.7.1__tar.gz

{structurize-3.7.0/structurize.egg-info → structurize-3.7.1}/PKG-INFO

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

{structurize-3.7.0 → structurize-3.7.1}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.7.0'
-__version_tuple__ = version_tuple = (3, 7, 0)
+__version__ = version = '3.7.1'
+__version_tuple__ = version_tuple = (3, 7, 1)
 
-__commit_id__ = commit_id = 'gd5dcf3fee'
+__commit_id__ = commit_id = 'g2f9460efb'

{structurize-3.7.0 → structurize-3.7.1}/avrotize/avrotocapnproto.py

@@ -8,6 +8,8 @@ import re
 import tempfile
 from typing import Any
 
+from avrotize.common import unique_name
+
 INDENT = "  "
 FILE_ID = "0xd12f8a7e9b0c4a6f"
 
@@ -41,6 +43,8 @@ class AvroToCapnpConverter:
         self.namespace = namespace
         self.named: dict[str, dict[str, Any]] = {}
         self.emitted: set[str] = set()
+        self.type_names: dict[int, str] = {}
+        self.top_level_type_names: set[str] = set()
 
     def convert(self, avro_schema: Any) -> str:
         schemas = avro_schema if isinstance(avro_schema, list) else [avro_schema]
@@ -48,6 +52,7 @@ class AvroToCapnpConverter:
             if isinstance(schema, dict) and schema.get("type") in {"record", "enum"}:
                 self.named[schema["name"]] = schema
                 self.named[_type_name(schema)] = schema
+                self._assign_type_name(schema, self.top_level_type_names)
         lines = [f"@{FILE_ID};", ""]
         if self.namespace:
             lines.append(f"# namespace: {self.namespace}")
@@ -57,83 +62,102 @@ class AvroToCapnpConverter:
             if isinstance(schema, dict) and schema.get("type") in {"enum", "record"}:
                 name = _type_name(schema)
                 if name not in self.emitted:
-                    lines.extend(self._render_named(schema, 0))
+                    lines.extend(self._render_named(schema, 0, self.top_level_type_names))
                     lines.append("")
         return "\n".join(lines).rstrip() + "\n"
 
-    def _render_named(self, schema: dict[str, Any], level: int) -> list[str]:
+    def _assign_type_name(self, schema: dict[str, Any], used: set[str] | None = None) -> str:
+        key = id(schema)
+        if key not in self.type_names:
+            self.type_names[key] = unique_name(_safe_ident(schema["name"]), used if used is not None else self.top_level_type_names)
+        return self.type_names[key]
+
+    def _render_named(self, schema: dict[str, Any], level: int, used_type_names: set[str] | None = None) -> list[str]:
         if schema.get("type") == "enum":
-            return self._render_enum(schema, level)
+            return self._render_enum(schema, level, used_type_names)
         if schema.get("type") == "record":
-            return self._render_struct(schema, level)
+            return self._render_struct(schema, level, used_type_names)
         return []
 
-    def _render_enum(self, schema: dict[str, Any], level: int) -> list[str]:
+    def _render_enum(self, schema: dict[str, Any], level: int, used_type_names: set[str] | None = None) -> list[str]:
         self.emitted.add(_type_name(schema))
-        lines = [f"{INDENT * level}enum {_safe_ident(schema['name'])} {{"]
+        lines = [f"{INDENT * level}enum {self._assign_type_name(schema, used_type_names)} {{"]
+        used_symbols: set[str] = set()
         for index, symbol in enumerate(schema.get("symbols", [])):
-            lines.append(f"{INDENT * (level + 1)}{_safe_ident(symbol)} @{index};")
+            lines.append(f"{INDENT * (level + 1)}{unique_name(_safe_ident(symbol), used_symbols)} @{index};")
         lines.append(f"{INDENT * level}}}")
         return lines
 
-    def _render_struct(self, schema: dict[str, Any], level: int) -> list[str]:
+    def _render_struct(self, schema: dict[str, Any], level: int, used_type_names: set[str] | None = None) -> list[str]:
         self.emitted.add(_type_name(schema))
-        lines = [f"{INDENT * level}struct {_safe_ident(schema['name'])} {{"]
+        lines = [f"{INDENT * level}struct {self._assign_type_name(schema, used_type_names)} {{"]
         fields = schema.get("fields", [])
-        grouped: dict[str, list[tuple[int, dict[str, Any], Any]]] = {}
-        normal: list[tuple[int, dict[str, Any], Any]] = []
+        grouped: dict[str, list[tuple[int, dict[str, Any], Any, str]]] = {}
+        normal: list[tuple[int, dict[str, Any], Any, str]] = []
+        used_fields: set[str] = set()
         for index, field in enumerate(fields):
             avro_type = field.get("type")
             union_name = field.get("capnpUnion")
-            item = (index, field, avro_type)
+            safe_field_name = unique_name(_safe_ident(field.get("name", f"field{index}")), used_fields)
+            item = (index, field, avro_type, safe_field_name)
             if union_name:
                 grouped.setdefault(str(union_name), []).append(item)
             else:
                 normal.append(item)
-        for index, field, avro_type in normal:
-            lines.extend(self._render_field(field, avro_type, index, level + 1))
+        nested_type_names: set[str] = set()
+        for index, field, avro_type, safe_field_name in normal:
+            lines.extend(self._render_field(field, avro_type, index, level + 1, safe_field_name, nested_type_names))
         for _, items in grouped.items():
             lines.append(f"{INDENT * (level + 1)}union {{")
-            for index, field, avro_type in items:
-                lines.extend(self._render_field(field, avro_type, index, level + 2))
+            for index, field, avro_type, safe_field_name in items:
+                lines.extend(self._render_field(field, avro_type, index, level + 2, safe_field_name, nested_type_names))
             lines.append(f"{INDENT * (level + 1)}}}")
         lines.append(f"{INDENT * level}}}")
         return lines
 
-    def _render_field(self, field: dict[str, Any], avro_type: Any, index: int, level: int) -> list[str]:
-        capnp_type, nested = self._capnp_type(avro_type, _safe_ident(field.get("name", f"field{index}")))
+    def _render_field(
+        self,
+        field: dict[str, Any],
+        avro_type: Any,
+        index: int,
+        level: int,
+        safe_field_name: str,
+        used_type_names: set[str],
+    ) -> list[str]:
+        capnp_type, nested = self._capnp_type(avro_type, safe_field_name, used_type_names)
         ordinal = index
         lines: list[str] = []
-        lines.extend(self._render_inline_nested(nested, level))
-        lines.append(f"{INDENT * level}{_safe_ident(field.get('name', f'field{index}'))} @{ordinal} :{capnp_type};")
+        lines.extend(self._render_inline_nested(nested, level, used_type_names))
+        lines.append(f"{INDENT * level}{safe_field_name} @{ordinal} :{capnp_type};")
         return lines
 
-    def _render_inline_nested(self, nested: list[dict[str, Any]], level: int) -> list[str]:
+    def _render_inline_nested(self, nested: list[dict[str, Any]], level: int, used_type_names: set[str]) -> list[str]:
         lines: list[str] = []
         for schema in nested:
-            lines.extend(self._render_named(schema, level))
+            lines.extend(self._render_named(schema, level, used_type_names))
         return lines
 
     def _non_null_union(self, avro_type: list[Any]) -> list[Any]:
         return [item for item in avro_type if item != "null" and not (isinstance(item, dict) and item.get("type") == "null")]
 
-    def _capnp_type(self, avro_type: Any, field_name: str) -> tuple[str, list[dict[str, Any]]]:
+    def _capnp_type(self, avro_type: Any, field_name: str, used_type_names: set[str] | None = None) -> tuple[str, list[dict[str, Any]]]:
+        used_type_names = used_type_names if used_type_names is not None else self.top_level_type_names
         if isinstance(avro_type, list):
             non_null = self._non_null_union(avro_type)
             if len(non_null) == 1:
-                return self._capnp_type(non_null[0], field_name)
+                return self._capnp_type(non_null[0], field_name, used_type_names)
             union_schema = {
                 "type": "record",
                 "name": f"{field_name[:1].upper()}{field_name[1:]}Choice",
                 "fields": [{"name": f"choice{i}", "type": t, "capnpUnion": "union"} for i, t in enumerate(non_null)],
             }
-            return union_schema["name"], [union_schema]
+            return self._assign_type_name(union_schema, used_type_names), [union_schema]
         if isinstance(avro_type, dict):
             avro_kind = avro_type.get("type")
             if isinstance(avro_kind, list):
-                return self._capnp_type(avro_kind, field_name)
+                return self._capnp_type(avro_kind, field_name, used_type_names)
             if avro_kind == "array":
-                item_type, nested = self._capnp_type(avro_type.get("items", "string"), f"{field_name}Item")
+                item_type, nested = self._capnp_type(avro_type.get("items", "string"), f"{field_name}Item", used_type_names)
                 return f"List({item_type})", nested
             if avro_kind == "map":
                 entry = {
@@ -144,19 +168,19 @@ class AvroToCapnpConverter:
                         {"name": "value", "type": avro_type.get("values", "string")},
                     ],
                 }
-                return f"List({entry['name']})", [entry]
+                return f"List({self._assign_type_name(entry, used_type_names)})", [entry]
             if avro_kind == "record":
-                return avro_type["name"], [avro_type]
+                return self._assign_type_name(avro_type, used_type_names), [avro_type]
             if avro_kind == "enum":
-                return avro_type["name"], [avro_type]
+                return self._assign_type_name(avro_type, used_type_names), [avro_type]
             if avro_kind == "fixed":
                 return "Data", []
-            return self._capnp_type(avro_kind, field_name)
+            return self._capnp_type(avro_kind, field_name, used_type_names)
         if isinstance(avro_type, str):
             named = self.named.get(avro_type)
             if named:
-                return named["name"], []
-            return self.primitive_map.get(avro_type, avro_type.split(".")[-1]), []
+                return self._assign_type_name(named), []
+            return self.primitive_map.get(avro_type, _safe_ident(avro_type.split(".")[-1])), []
         return "Text", []
 
 

{structurize-3.7.0 → structurize-3.7.1}/avrotize/avrotocsharp.py

@@ -8,7 +8,7 @@ import re
 from typing import Any, Dict, List, Tuple, Union, cast
 import uuid
 
-from avrotize.common import build_flat_type_dict, inline_avro_references, is_generic_avro_type, pascal, process_template
+from avrotize.common import build_flat_type_dict, inline_avro_references, is_generic_avro_type, pascal, process_template, unique_name
 from avrotize.constants import (
     CSHARP_AVRO_VERSION,
     NEWTONSOFT_JSON_VERSION,
@@ -76,7 +76,7 @@ class AvroToCSharp:
         else:
             return name
 
-    def map_primitive_to_csharp(self, avro_type: str) -> str:
+    def map_primitive_to_csharp(self, avro_type: str, parent_namespace: str = '') -> str:
         """ Maps Avro primitive types to C# types """
         mapping = {
             'null': 'void',  # Placeholder, actual handling for nullable types is in the union logic
@@ -92,9 +92,43 @@ class AvroToCSharp:
         if qualified_class_name in self.generated_avro_types:
             result = qualified_class_name
         else:
-            result = mapping.get(avro_type, 'object')
+            result = mapping.get(avro_type, '')
+            if not result:
+                avro_type_name = avro_type if '.' in avro_type or not parent_namespace else f"{parent_namespace}.{avro_type}"
+                if avro_type_name in self.type_dict:
+                    namespace = ".".join(avro_type_name.split('.')[:-1])
+                    name = avro_type_name.split('.')[-1]
+                    result = 'global::'+self.get_qualified_name(pascal(self.concat_namespace(self.base_namespace, namespace)), pascal(name))
+                else:
+                    result = 'object'
         return result
 
+    def safe_identifier(self, name: str, class_name: str = '', fallback_prefix: str = 'field', allow_unicode: bool = False) -> str:
+        """Converts a source name to a safe C# identifier."""
+        safe = re.sub(r'[^\w]', '_', str(name), flags=re.UNICODE) if allow_unicode else re.sub(r'[^a-zA-Z0-9_]', '_', str(name))
+        safe = safe.strip('_') if safe != name else safe
+        starts_ok = safe and (safe[0] == '_' or safe[0] == '@' or (safe[0].isalpha() if allow_unicode else re.match(r'^[a-zA-Z_@]', safe)))
+        if not starts_ok:
+            safe = '_' + safe if safe and safe[0].isdigit() else f"{fallback_prefix}_unnamed"
+        if self.is_csharp_reserved_word(safe):
+            safe = f"@{safe}"
+        if class_name and safe == class_name:
+            safe += "_"
+        return safe
+
+    def safe_enum_member_name(self, symbol: str, used: set) -> str:
+        """Converts an Avro enum symbol to a unique C# enum member name."""
+        parts = [part for part in re.split(r'[^\w]+', str(symbol), flags=re.UNICODE) if part]
+        if not parts:
+            candidate = "Value"
+        else:
+            candidate = ''.join(part if part.isupper() else part[:1].upper() + part[1:] for part in parts)
+        if not candidate or not (candidate[0] == '_' or candidate[0].isalpha()):
+            candidate = f"Value{candidate}"
+        if self.is_csharp_reserved_word(candidate):
+            candidate = f"@{candidate}"
+        return unique_name(candidate, used)
+
     def is_csharp_reserved_word(self, word: str) -> bool:
         """ Checks if a word is a reserved C# keyword """
         reserved_words = [
@@ -133,7 +167,7 @@ class AvroToCSharp:
     def convert_avro_type_to_csharp(self, class_name: str, field_name: str, avro_type: JsonNode, parent_namespace: str) -> str:
         """ Converts Avro type to C# type """
         if isinstance(avro_type, str):
-            return self.map_primitive_to_csharp(avro_type)
+            return self.map_primitive_to_csharp(avro_type, parent_namespace)
         elif isinstance(avro_type, list):
             # Handle nullable types and unions
             if is_generic_avro_type(avro_type):
@@ -194,7 +228,8 @@ class AvroToCSharp:
             class_definition += "[MessagePackObject]\n"
 
         fields = avro_schema.get('fields', [])
-        fields_str = [self.generate_property(index + 1, field, class_name, avro_namespace) for index, field in enumerate(fields)]
+        property_names = self.get_csharp_property_names(fields, class_name)
+        fields_str = [self.generate_property(index + 1, field, class_name, avro_namespace, property_names[index]) for index, field in enumerate(fields)]
         class_body = "\n".join(fields_str)
         class_definition += f"public partial class {class_name}"
         if self.avro_annotation:
@@ -229,14 +264,8 @@ class AvroToCSharp:
             put_method = f"{INDENT}void global::Avro.Specific.ISpecificRecord.Put(int fieldPos, object fieldValue)\n" + \
                 INDENT+"{"+f"\n{INDENT*2}switch (fieldPos)\n{INDENT*2}"+"{"
             for pos, field in enumerate(avro_schema.get('fields', [])):
-                field_name = field['name']
-                if self.is_csharp_reserved_word(field_name):
-                    field_name = f"@{field_name}"
-                field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], avro_namespace)
-                if self.pascal_properties:
-                    field_name = pascal(field_name)
-                if field_name == class_name:
-                    field_name += "_"
+                field_name = property_names[pos]
+                field_type = self.convert_avro_type_to_csharp(class_name, field['name'], field['type'], avro_namespace)
                 if field_type in self.generated_types:
                     if self.generated_types[field_type] == "union":
                         get_method += f"\n{INDENT*3}case {pos}: return this.{field_name}?.ToObject();"
@@ -279,7 +308,7 @@ class AvroToCSharp:
             cbor_annotation=self.cbor_annotation,
             json_match_clauses=self.create_is_json_match_clauses(avro_schema, avro_namespace, class_name),
             openapi_generator_compat=self.openapi_generator_compat,
-            openapi_fields=self.get_openapi_compat_fields(fields, class_name, avro_namespace)
+            openapi_fields=self.get_openapi_compat_fields(fields, class_name, avro_namespace, property_names)
         )
 
         # emit Equals and GetHashCode for value equality
@@ -294,26 +323,45 @@ class AvroToCSharp:
         self.generated_avro_types[ref] = avro_schema
         return ref
 
+    def get_csharp_property_names(self, fields: List[Dict], class_name: str) -> List[str]:
+        """Returns unique C# property names for the fields in a class."""
+        used: set[str] = set()
+        property_names: List[str] = []
+        for field in fields:
+            raw_name = str(field['name'])
+            if self.openapi_generator_compat:
+                safe_name = self.safe_identifier(raw_name, class_name)
+                candidate = self.get_openapi_property_name(safe_name, class_name)
+                property_names.append(re.sub(r'_(\d+)$', r'\1', unique_name(candidate, used)))
+            else:
+                field_name = self.safe_identifier(raw_name, class_name, allow_unicode=True)
+                if self.pascal_properties:
+                    field_name = pascal(field_name.lstrip('@'))
+                    if self.is_csharp_reserved_word(field_name):
+                        field_name = f"@{field_name}"
+                    if field_name == class_name:
+                        field_name += "_"
+                property_names.append(unique_name(field_name, used))
+        return property_names
+
     def create_is_json_match_clauses(self, avro_schema, parent_namespace, class_name) -> List[str]:
         """ Generates the IsJsonMatch method for System.Text.Json """
         clauses: List[str] = []
-        for field in avro_schema.get('fields', []):
-            field_name = field['name']
-            if self.is_csharp_reserved_word(field_name):
-                field_name = f"@{field_name}"
-            if field_name == class_name:
-                field_name += "_"
+        fields = avro_schema.get('fields', [])
+        used_names: set[str] = set()
+        for field in fields:
+            field_name = unique_name(self.safe_identifier(field['name'], class_name, allow_unicode=True), used_names)
             field_type = self.convert_avro_type_to_csharp(
-                    class_name, field_name, field['type'], parent_namespace)
-            clauses.append(self.get_is_json_match_clause(class_name, field_name, field_type))
+                    class_name, field['name'], field['type'], parent_namespace)
+            clauses.append(self.get_is_json_match_clause(class_name, field_name, field_type, str(field['name'])))
         if len(clauses) == 0:
             clauses.append("true")
         return clauses
 
-    def get_is_json_match_clause(self, class_name, field_name, field_type) -> str:
+    def get_is_json_match_clause(self, class_name, field_name, field_type, wire_name: str | None = None) -> str:
         """ Generates the IsJsonMatch clause for a field """
         class_definition = ''
-        field_name_js = field_name[1:] if field_name[0] == '@' else field_name
+        field_name_js = wire_name if wire_name is not None else (field_name[1:] if field_name[0] == '@' else field_name)
         is_optional = field_type[-1] == '?'
         field_type = field_type[:-1] if is_optional else field_type
         if field_type == 'byte[]':
@@ -399,18 +447,11 @@ class AvroToCSharp:
         
         # Build equality comparisons for each field
         equality_checks = []
-        for field in fields:
-            field_name = field['name']
-            if self.is_csharp_reserved_word(field_name):
-                field_name = f"@{field_name}"
-            if self.openapi_generator_compat:
-                field_name = self.get_openapi_property_name(field_name, class_name)
-            elif self.pascal_properties:
-                field_name = pascal(field_name)
-            if field_name == class_name:
-                field_name += "_"
+        property_names = self.get_csharp_property_names(fields, class_name)
+        for index, field in enumerate(fields):
+            field_name = property_names[index]
             
-            field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], parent_namespace)
+            field_type = self.convert_avro_type_to_csharp(class_name, field['name'], field['type'], parent_namespace)
             
             # Handle different types of comparisons
             if field_type == 'byte[]' or field_type == 'byte[]?':
@@ -443,18 +484,10 @@ class AvroToCSharp:
         
         # Collect field names for HashCode.Combine
         hash_fields = []
-        for field in fields:
-            field_name = field['name']
-            if self.is_csharp_reserved_word(field_name):
-                field_name = f"@{field_name}"
-            if self.openapi_generator_compat:
-                field_name = self.get_openapi_property_name(field_name, class_name)
-            elif self.pascal_properties:
-                field_name = pascal(field_name)
-            if field_name == class_name:
-                field_name += "_"
-            
-            field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], parent_namespace)
+        for index, field in enumerate(fields):
+            field_name = property_names[index]
+             
+            field_type = self.convert_avro_type_to_csharp(class_name, field['name'], field['type'], parent_namespace)
             
             # Handle special types that need custom hash code computation
             if field_type == 'byte[]' or field_type == 'byte[]?':
@@ -502,10 +535,14 @@ class AvroToCSharp:
             else:
                 enum_definition += f"[XmlType(\"{enum_name}\")]\n"
 
-        if self.system_xml_annotation:
-            symbols_str = [f"{INDENT}/// <summary>\n{INDENT}/// {symbol}\n{INDENT}/// </summary>\n{INDENT}[XmlEnum(Name=\"{symbol}\")]\n{INDENT}{symbol}" for symbol in avro_schema['symbols']]
-        else:
-            symbols_str = [f"{INDENT}/// <summary>\n{INDENT}/// {symbol}\n{INDENT}/// </summary>\n{INDENT}{symbol}" for symbol in avro_schema['symbols']]
+        used_symbols: set[str] = set()
+        symbols_str = []
+        for symbol in avro_schema['symbols']:
+            member_name = self.safe_enum_member_name(str(symbol), used_symbols)
+            if self.system_xml_annotation:
+                symbols_str.append(f"{INDENT}/// <summary>\n{INDENT}/// {member_name}\n{INDENT}/// </summary>\n{INDENT}[XmlEnum(Name=\"{symbol}\")]\n{INDENT}{member_name}")
+            else:
+                symbols_str.append(f"{INDENT}/// <summary>\n{INDENT}/// {member_name}\n{INDENT}/// </summary>\n{INDENT}{member_name}")
         enum_body = ",\n".join(symbols_str)
         enum_definition += f"public enum {enum_name}\n{{\n{enum_body}\n}}"
 
@@ -753,19 +790,14 @@ class AvroToCSharp:
             return avro_type.get('type') == 'enum'
         return False
 
-    def generate_property(self, field_index: int, field: Dict, class_name: str, parent_namespace: str) -> str:
+    def generate_property(self, field_index: int, field: Dict, class_name: str, parent_namespace: str, property_name: str | None = None) -> str:
         """ Generates a property """
         is_enum_type = self.is_enum_type(field['type'])
         field_type = self.convert_avro_type_to_csharp(
             class_name, field['name'], field['type'], parent_namespace)
         field_default = field.get('const', field.get('default', None))
-        annotation_name = field_name = field['name']
-        if self.is_csharp_reserved_word(field_name):
-            field_name = f"@{field_name}"
-        if self.pascal_properties:
-            field_name = pascal(field_name)
-        if field_name == class_name:
-            field_name += "_"
+        annotation_name = field['name']
+        field_name = property_name if property_name is not None else self.get_csharp_property_names([field], class_name)[0]
         if self.openapi_generator_compat:
             return self.generate_openapi_compat_property(field, field_type, field_name, annotation_name, class_name)
         prop = ''
@@ -809,7 +841,8 @@ class AvroToCSharp:
                 # For enum types, use qualified enum value (e.g., Type.Circle)
                 # Get the base enum type name (strip nullable ? suffix if present)
                 enum_type = field_type.rstrip('?')
-                initialization = f" = {enum_type}.{field_default};"
+                enum_default = self.safe_enum_member_name(str(field_default), set())
+                initialization = f" = {enum_type}.{enum_default};"
             elif isinstance(field_default, str):
                 initialization = f" = \"{field_default}\";"
             else:
@@ -845,7 +878,7 @@ class AvroToCSharp:
 
     def generate_openapi_compat_property(self, field: Dict, field_type: str, field_name: str, annotation_name: str, class_name: str) -> str:
         """Generates an OpenAPI Generator-compatible property."""
-        property_name = self.get_openapi_property_name(field_name, class_name)
+        property_name = field_name
         doc = field.get('doc', property_name)
         prop = f"{INDENT}/// <summary>\n{INDENT}/// {doc}\n{INDENT}/// </summary>\n"
         if self.is_openapi_optional_avro_field(field):
@@ -866,14 +899,15 @@ class AvroToCSharp:
             prop += f"{INDENT}public {field_type} {property_name} {{ get; set; }}{initialization}"
         return prop
 
-    def get_openapi_compat_fields(self, fields: List[Dict], class_name: str, parent_namespace: str) -> List[Dict[str, Any]]:
+    def get_openapi_compat_fields(self, fields: List[Dict], class_name: str, parent_namespace: str, property_names: List[str] | None = None) -> List[Dict[str, Any]]:
         """Builds template metadata for OpenAPI Generator-compatible converters."""
+        if property_names is None:
+            property_names = self.get_csharp_property_names(fields, class_name)
         result: List[Dict[str, Any]] = []
-        for field in fields:
+        for index, field in enumerate(fields):
             raw_name = field['name']
-            safe_name = f"@{raw_name}" if self.is_csharp_reserved_word(raw_name) else raw_name
             field_type = self.convert_avro_type_to_csharp(class_name, raw_name, field['type'], parent_namespace)
-            property_name = self.get_openapi_property_name(safe_name, class_name)
+            property_name = property_names[index]
             result.append({
                 "wire_name": raw_name,
                 "property_name": property_name,
@@ -1040,17 +1074,11 @@ class AvroToCSharp:
 
         fields: List[Field] = []
         if avro_schema and 'fields' in avro_schema:
-            for field in cast(List[Dict[str,JsonNode]],avro_schema['fields']):
-                field_name = str(field['name'])
-                if self.is_csharp_reserved_word(field_name):
-                    field_name = f"@{field_name}"
-                if self.openapi_generator_compat:
-                    field_name = self.get_openapi_property_name(field_name, class_name)
-                elif self.pascal_properties:
-                    field_name = pascal(field_name)
-                if field_name == class_name:
-                    field_name += "_"
-                field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], str(avro_schema.get('namespace', '')))
+            avro_fields = cast(List[Dict[str,JsonNode]], avro_schema['fields'])
+            property_names = self.get_csharp_property_names(avro_fields, class_name)
+            for index, field in enumerate(avro_fields):
+                field_name = property_names[index]
+                field_type = self.convert_avro_type_to_csharp(class_name, str(field['name']), field['type'], str(avro_schema.get('namespace', '')))
                 is_class = field_type in self.generated_types and self.generated_types[field_type] == "class"
                 is_enum = self.is_enum_type(field['type'])
                 is_union = field_type in self.generated_types and self.generated_types[field_type] == "union"
@@ -1128,6 +1156,12 @@ class AvroToCSharp:
         
         self.schema_doc = schema
         self.type_dict = build_flat_type_dict(self.schema_doc)
+        if isinstance(self.schema_doc, list):
+            for type_schema in self.type_dict.values():
+                if isinstance(type_schema, dict) and type_schema.get('type') in ['record', 'enum']:
+                    full_name = self.concat_namespace(str(type_schema.get('namespace', '')), str(type_schema.get('name', '')))
+                    if full_name not in [self.concat_namespace(str(item.get('namespace', '')), str(item.get('name', ''))) for item in self.schema_doc if isinstance(item, dict)]:
+                        self.schema_doc.append(type_schema)
         if not os.path.exists(output_dir):
             os.makedirs(output_dir, exist_ok=True)
         if not glob.glob(os.path.join(output_dir, "src", "*.sln")):

{structurize-3.7.0 → structurize-3.7.1}/avrotize/avrotoflatbuffers.py

@@ -7,6 +7,8 @@ import os
 import re
 from typing import Any
 
+from avrotize.common import unique_name
+
 
 def _sanitize(name: str) -> str:
     cleaned = re.sub(r"\W", "_", name)
@@ -25,16 +27,21 @@ class AvroToFlatBuffersConverter:
         self.namespace_override = namespace
         self.named: dict[str, dict[str, Any]] = {}
         self.union_defs: dict[str, list[str]] = {}
+        self.type_names: dict[str, str] = {}
+        self.used_top_names: set[str] = set()
 
     def convert_file(self, avro_schema_path: str) -> str:
         with open(avro_schema_path, "r", encoding="utf-8") as f:
             schema = json.load(f)
         schemas = schema if isinstance(schema, list) else [schema]
+        self._prepare_names(schemas)
         for item in schemas:
             if isinstance(item, dict) and item.get("type") in {"record", "enum"}:
                 qn = self.qualified_name(item)
                 self.named[qn] = item
                 self.named[item["name"]] = item
+                self.named[self.fbs_type_name(qn)] = item
+                self.named[self.fbs_type_name(item["name"])] = item
         namespace = self.namespace_override or self.first_namespace(schemas)
         lines: list[str] = []
         if namespace:
@@ -53,9 +60,22 @@ class AvroToFlatBuffersConverter:
         lines.extend(record_lines)
         root = self.find_root(schemas)
         if root:
-            lines.append(f"root_type {root};")
+            lines.append(f"root_type {self.fbs_type_name(root)};")
         return "\n".join(lines).rstrip() + "\n"
 
+    def _prepare_names(self, schemas: list[Any]) -> None:
+        self.type_names = {}
+        self.used_top_names = set()
+        for item in schemas:
+            if isinstance(item, dict) and item.get("type") in {"record", "enum"}:
+                candidate = _sanitize(item["name"])
+                converted = unique_name(candidate, self.used_top_names)
+                self.type_names[item["name"]] = converted
+                self.type_names[self.qualified_name(item)] = converted
+
+    def fbs_type_name(self, name: str) -> str:
+        return self.type_names.get(name, self.type_names.get(name.split(".")[-1], _sanitize(name.split(".")[-1])))
+
     @staticmethod
     def qualified_name(schema: dict[str, Any]) -> str:
         return f"{schema.get('namespace')}.{schema['name']}" if schema.get("namespace") else schema["name"]
@@ -80,15 +100,19 @@ class AvroToFlatBuffersConverter:
     def render_enum(self, schema: dict[str, Any]) -> list[str]:
         ordinals = schema.get("ordinals", {})
         parts = []
+        used_symbols: set[str] = set()
         for i, symbol in enumerate(schema.get("symbols", [])):
             value = ordinals.get(symbol, i)
-            parts.append(f"{_sanitize(symbol)} = {value}")
-        return [f"enum {schema['name']} : int {{ {', '.join(parts)} }}"]
+            parts.append(f"{unique_name(_sanitize(symbol), used_symbols)} = {value}")
+        return [f"enum {self.fbs_type_name(self.qualified_name(schema))} : int {{ {', '.join(parts)} }}"]
 
     def render_record(self, schema: dict[str, Any]) -> list[str]:
-        lines = [f"table {schema['name']} {{"]
+        record_name = self.fbs_type_name(self.qualified_name(schema))
+        lines = [f"table {record_name} {{"]
+        used_fields: set[str] = set()
         for field in schema.get("fields", []):
-            fbs_type, nullable = self.avro_type_to_fbs(field["type"], schema["name"], field["name"])
+            field_name = unique_name(_sanitize(field["name"]), used_fields)
+            fbs_type, nullable = self.avro_type_to_fbs(field["type"], record_name, field_name)
             default = ""
             avro_default = field.get("fbsDefault", field.get("default"))
             if avro_default is not None and not isinstance(field["type"], list):
@@ -96,7 +120,7 @@ class AvroToFlatBuffersConverter:
             attr = ""
             if not nullable and self.can_be_required(fbs_type):
                 attr = " (required)"
-            lines.append(f"  {_sanitize(field['name'])}: {fbs_type}{default}{attr};")
+            lines.append(f"  {field_name}: {fbs_type}{default}{attr};")
         lines.append("}")
         return lines
 
@@ -125,11 +149,11 @@ class AvroToFlatBuffersConverter:
                 fbs, _ = self.avro_type_to_fbs(non_null[0], record_name, field_name)
                 return fbs, nullable
             members = [self.avro_type_to_fbs(t, record_name, field_name)[0] for t in non_null]
-            union_name = f"{record_name}_{field_name}_Union"
+            union_name = unique_name(_sanitize(f"{record_name}_{field_name}_Union"), self.used_top_names)
             self.union_defs[union_name] = [m for m in members if not m.startswith("[")]
             return union_name, nullable
         if isinstance(avro_type, str):
-            return self.primitive_map.get(avro_type, avro_type.split(".")[-1]), nullable
+            return self.primitive_map.get(avro_type, self.fbs_type_name(avro_type)), nullable
         if isinstance(avro_type, dict):
             typ = avro_type.get("type")
             if typ == "array":
@@ -139,7 +163,7 @@ class AvroToFlatBuffersConverter:
                 return "string", nullable
             if typ == "enum" or typ == "record":
                 self.named[avro_type["name"]] = avro_type
-                return avro_type["name"], nullable
+                return self.fbs_type_name(avro_type["name"]), nullable
             if typ == "bytes":
                 return "[ubyte]", nullable
             return self.primitive_map.get(typ, typ), nullable